rtdb_relay 0.2.0: Dart client half

Moves the tutor app's generic relay client (RTDB REST/SSE, e2e
sealing per an app layout, request hub, rev watcher, passphrase gate,
Google->Firebase session, desktop credential adoption) into
rtdb_relay/dart. The tutor vectors and a differential test against
the tutor's frozen pre-extraction sealer pin the wire format.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WzxdWYeKVg9WihaikbfDSe
This commit is contained in:
Krzysztof Rudnicki 2026-11-17 21:27:29 +01:00
parent 905d13774a
commit f2150949a0
38 changed files with 4812 additions and 6 deletions

View File

@ -0,0 +1,36 @@
name: rtdb_relay dart tests
on:
push:
branches: [main]
paths: ['rtdb_relay/dart/**']
pull_request:
branches: [main]
paths: ['rtdb_relay/dart/**']
jobs:
test:
runs-on: ubuntu-latest
defaults:
run:
working-directory: rtdb_relay/dart
steps:
- uses: actions/checkout@v4
- name: Set up Flutter
uses: subosito/flutter-action@v2
with:
channel: stable
- name: Install dependencies
run: flutter pub get
- name: Analyze
run: flutter analyze
- name: Run tests with coverage
run: flutter test --coverage
- name: Enforce 100% line coverage
run: scripts/check_coverage.sh coverage/lcov.info 100

View File

@ -76,14 +76,85 @@ from rtdb_relay import presence, sse, mirror
local copy of a streamed node. To publish a sealed snapshot node, `await
rtdb.put("<unit path>", value)`.
## Dart API (the Flutter client)
## Dart API (the Flutter client, `dart/`)
Not extracted yet: the tutor app's `lib/sync/` and `lib/relay/` still hold
the client half. Until it moves here, a new client follows the wire format
above (`requests/{rid}/req` sealed with crdt_sync's Dart `E2eCipher`, then
listen on `requests/{rid}/result`).
```yaml
rtdb_relay:
git:
url: https://github.com/kuhyx/utils
ref: rtdb-relay-v0.2.0
path: rtdb_relay/dart
```
## Develop
`import 'package:rtdb_relay/rtdb_relay.dart';` The tutor app uses it since
v0.2.0 (`lib/sync/*.dart` there are thin tutor bindings: a worked example).
A request is written by the app and answered by the worker; the app never
writes `claim` or `result`.
- `RelayLayout(String base, {required List<String> clear, required
Map<String, Set<String>> units})`: the tree rules, same patterns as the
Python `Layout`. `root` is crdt_sync's e2e prefix of `base`
(`todoimpl/v1` -> `todoimpl/v1-e2e`); the passphrase header lives at
`<base>/e2e`. Start from `kRelayClear` + `kRelayUnits` (claim clear;
`requests/*/req` keeps `created`, `requests/*/result` keeps `at`,
`presence/workers/*` keeps `beat`). `classify(parts) -> E2eRule`,
`unitPath(rel) -> String?`, `rel(path) -> String?`. Unknown paths throw
`E2eLayoutError` on write.
- `RelaySealer(E2eCipher cipher, {required RelayLayout layout, String?
root})`: `seal(rel, value)`, `sealPatch(rel, body)`, `open(rel, value)`.
`E2eGate` makes one for you; build it by hand only in tests.
- `RtdbClient({required RelayLayout layout, required String databaseUrl,
required IdTokenSource idToken, http.Client? httpClient, String?
namespace, RelaySealer? sealer, bool sealRequired = false})`:
`get(path, {query})`, `keys(path)`, `getTagged(path) -> Tagged`,
`put(path, value)`, `putIfMatch(path, value, etag) -> ConditionalResult`,
`deleteIfMatch(path, etag)`, `patch(path, Map)`, `delete(path)`,
`close()`. Paths are full (`<root>/requests/<rid>/req`). Errors are
`RtdbError` (`isAuth`, `isTransient`); with `sealRequired` nothing under
the root is sent before the key is unlocked. `keyRangeQuery(startAt)`
gives the `$key`-ordered range query (the only index the rules allow).
- `RtdbStream(RtdbClient client, {Sleep? sleep})`: `listen(path, {query})
-> Stream<RtdbEvent>` (SSE, reconnects with backoff, opens sealed
units; events `RtdbPut`, `RtdbPatch`, `RtdbConnected`,
`RtdbDisconnected`, ...). `applyEvent(tree, event)`, `getAt(tree, path)`
and `setAt(tree, path, value)` keep a local copy of a streamed node.
- `RequestHub(RtdbStream stream, String requestsPath)`: one ranged listen
for every request in flight. `watch(rid) -> Stream<Object?>` yields the
`requests/<rid>` node (`req`, `claim`, `result`) each time it changes;
`inFlight` counts the followed requests. To send: `put('<root>/requests/
<rid>/req', {'kind': k, 'dev': deviceId, 'created': {'.sv':
'timestamp'}, 'sent_at': ms, 'body': {...}})` with a fresh ULID `rid`,
then `watch(rid)` until `result` appears (`ok`, or `code`/`error`/`retry`).
- `RevWatcher(RtdbStream stream, String path, {WidgetsBinding? binding,
ValueListenable<int>? yieldTo})`: `changesOf(key) -> Stream<int>` emits
real moves of `rev/<key>` only; pauses while the app is hidden and while
`yieldTo` (pass `RequestHub.inFlight`) is above 0. `revOf(rev, key)`,
`foregroundFor(state)`.
- `E2eGate({required RtdbClient client, FlutterSecureStorage storage,
Argon2Params params})`: `unlock() -> Future<bool>` opens the key from the
keystore passphrase (crdt_sync_flutter) and sets `client.sealer`;
`locked`, `reason`.
- `RelayFirebaseConfig({apiKey, databaseUrl, syncUid, serverClientId})`
(const; keep the values in a gitignored generated file) and
`RelayAuth({required RelayFirebaseConfig config, required
GoogleTokenFetcher googleToken, required FirebaseCredentialStore store,
http.Client? httpClient, DateTime Function()? clock, Future<bool>
Function()? adopt})`: `hasSession()`, `signInWithGoogle({tokenFetcher})
-> SignInOutcome` (refuses a Google account whose uid is not
`syncUid`), `idToken()` (pass `auth.idToken` to `RtdbClient`),
`signOut()`. `googleToken`: crdt_sync_flutter's `googleIdToken`.
`secureCredentialStore(String key)` is the keystore-backed store.
- Desktop (web in a Chrome `--app` window): `adoptWrapperCredentials(base:,
client:, store:, expectedUid:)` takes the PC server's seeded session once
from `<base>sync-credentials`; pass it as `RelayAuth.adopt`.
Develop: `cd dart && fvm flutter test --coverage &&
scripts/check_coverage.sh coverage/lcov.info 100`; `fvm flutter analyze`.
`test/data/e2e_vectors.json` (the tutor's contract vectors) and
`test/differential_test.dart` (the tutor's pre-extraction sealer, frozen in
`test/support/`) pin the wire format.
## Develop (Python)
`uv venv --python 3.15 .venv && uv pip install -e . pytest==9.2.0
pytest-cov==7.1.0 ruff==0.17.4 mypy==2.4.1`, then `scripts/run_subproject_tests.sh rtdb_relay`

3
rtdb_relay/dart/.fvmrc Normal file
View File

@ -0,0 +1,3 @@
{
"flutter": "3.50.0"
}

3
rtdb_relay/dart/.gitignore vendored Normal file
View File

@ -0,0 +1,3 @@
.dart_tool/
build/
coverage/

View File

@ -0,0 +1,37 @@
include: package:very_good_analysis/analysis_options.yaml
analyzer:
language:
strict-casts: true
strict-inference: true
strict-raw-types: true
errors:
# Promote key lints to errors so they fail CI, not just warn.
missing_required_param: error
unnecessary_null_comparison: error
dead_code: error
invalid_annotation_target: error
exclude:
- build/**
- "**/*.g.dart"
- "**/*.freezed.dart"
- android/**
- ios/**
- web/**
- windows/**
- macos/**
- linux/**
linter:
rules:
# very_good_analysis enables most rules; add extras it doesn't include.
always_use_package_imports: true
avoid_print: true
avoid_relative_lib_imports: true
cancel_subscriptions: true
close_sinks: true
comment_references: false # conflicts with typical Flutter API docs style
directives_ordering: true
lines_longer_than_80_chars: true
public_member_api_docs: true
unawaited_futures: true

View File

@ -0,0 +1,17 @@
/// The Flutter client half of the sealed RTDB request relay: REST + SSE
/// over Firebase RTDB, end-to-end sealing per an app's [RelayLayout], the
/// shared `requests` listen, the `rev` watcher, the passphrase gate and the
/// Google -> Firebase session. The PC half is the Python `rtdb_relay`.
library;
export 'src/auth.dart';
export 'src/e2e_gate.dart';
export 'src/json_tree.dart';
export 'src/layout.dart';
export 'src/request_hub.dart';
export 'src/rev_watcher.dart';
export 'src/rtdb_client.dart';
export 'src/rtdb_event.dart';
export 'src/rtdb_stream.dart';
export 'src/sealer.dart';
export 'src/wrapper_credentials.dart';

View File

@ -0,0 +1,150 @@
/// The signed-in session: Google ID token -> Firebase refresh token in the
/// keystore -> short-lived ID tokens for every RTDB request.
///
/// "Connected" means a stored session (refresh token), never an account
/// marker: that confusion kept phones "not connected" while their credential
/// sat unused in the keystore (todo, 2026-08-11).
library;
import 'dart:developer';
import 'package:crdt_sync/crdt_sync.dart'
show
FirebaseAuthError,
FirebaseCredentialStore,
FirebaseTokenProvider,
SecureCredentialStore;
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:http/http.dart' as http;
/// Outcome of an interactive sign-in.
enum SignInOutcome {
/// A session is stored; the app can sync.
signedIn,
/// The user dismissed the picker, or Google sign-in is unavailable.
cancelled,
}
/// The Firebase identifiers an app build talks to. Keep the literal values
/// out of public source (a gitignored generated file).
class RelayFirebaseConfig {
/// Creates a config; tests pass fakes.
const new({
required this.apiKey,
required this.databaseUrl,
required this.syncUid,
required this.serverClientId,
});
/// Web API key of the Firebase project.
final String apiKey;
/// Regional RTDB URL.
final String databaseUrl;
/// The uid the sync account must resolve to. A wrong Google account signs
/// up a second user; this guard refuses it before anything is stored.
final String syncUid;
/// Google *Web* OAuth client id, used as the ID-token audience.
final String serverClientId;
}
/// Fetches a Google ID token for [serverClientId]'s audience; null when the
/// user cancelled or sign-in is unavailable. crdt_sync_flutter's
/// `googleIdToken` fits.
typedef GoogleTokenFetcher = Future<String?> Function({
required String serverClientId,
});
/// Owns the Firebase session for this install.
class RelayAuth {
/// Creates the auth wrapper. Tests pass a memory [store] and fake [http].
new({
required this.config,
required this.googleToken,
required FirebaseCredentialStore store,
http.Client? httpClient,
DateTime Function()? clock,
this.adopt,
}) : provider = FirebaseTokenProvider(
apiKey: config.apiKey,
store: store,
httpClient: httpClient,
clock: clock,
);
/// Desktop only: adopts the PC's seeded session from the wrapper when
/// no session is stored (see `wrapper_credentials.dart`). True if adopted.
final Future<bool> Function()? adopt;
/// The build's Firebase identifiers.
final RelayFirebaseConfig config;
/// The interactive Google sign-in.
final GoogleTokenFetcher googleToken;
/// Mints ID tokens, refreshing from the stored refresh token.
final FirebaseTokenProvider provider;
/// Whether a session is stored. Never throws: an unreadable store reads
/// as "not signed in", and the sign-in screen repairs it.
Future<bool> hasSession() async {
try {
if (await provider.hasSession()) return true;
final adopt = this.adopt;
return adopt != null && await adopt() && await provider.hasSession();
} on Object catch (error, stackTrace) {
// `on Object`: an ArgumentError (Uri.base on Android) is an Error, not
// an Exception, and escaped `on Exception` in todo.
log(
'session probe failed; treating as signed out',
level: 1000,
error: error,
stackTrace: stackTrace,
);
return false;
}
}
/// Interactive Google sign-in with the expected-uid guard.
///
/// Throws [FirebaseAuthError] when Google resolves to a different uid:
/// picking the wrong account would otherwise silently sign up a second
/// user. Nothing is stored in that case.
Future<SignInOutcome> signInWithGoogle({
Future<String?> Function()? tokenFetcher,
}) async {
final token =
await (tokenFetcher ??
() => googleToken(serverClientId: config.serverClientId))();
if (token == null) return SignInOutcome.cancelled;
await provider.signInWithGoogle(
idToken: token,
expectedUid: config.syncUid,
);
return SignInOutcome.signedIn;
}
/// A currently valid ID token; throws [FirebaseAuthError] when signed out
/// or the refresh token was revoked (the session is then cleared).
Future<String> idToken() => provider.idToken();
/// Forgets the stored session.
Future<void> signOut() => provider.signOut();
}
/// The keystore-backed credential store (Android keystore; web storage)
/// under [key] (e.g. `tutor.firebase.credentials`).
// coverage:ignore-start
FirebaseCredentialStore secureCredentialStore(String key) {
const secure = FlutterSecureStorage();
return SecureCredentialStore(
read: (k) => secure.read(key: k),
write: (k, v) => secure.write(key: k, value: v),
delete: (k) => secure.delete(key: k),
key: key,
);
}
// coverage:ignore-end

View File

@ -0,0 +1,113 @@
/// Unlocks an app's e2e key: Argon2id of the shared crdt-sync passphrase,
/// read from and cached in the OS keystore by crdt_sync_flutter
/// (tutor DOCS-contract §12). Until it opens, [RtdbClient] sends nothing.
library;
import 'package:crdt_sync/crdt_sync.dart'
show
Argon2Params,
E2eLocked,
E2eReady,
E2eState,
RemoteStore,
RemoteSyncError;
import 'package:crdt_sync_flutter/crdt_sync_flutter.dart'
show kSecureStorage, openEncryptedStoreFromKeystore;
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:rtdb_relay/src/rtdb_client.dart';
import 'package:rtdb_relay/src/sealer.dart';
/// Opens [client]'s sealer from the keystore; [locked] until it did.
class E2eGate {
/// Creates the gate. [params] is lowered only by tests.
new({
required this.client,
this.storage = kSecureStorage,
this.params = Argon2Params.recommended,
});
/// The client whose sealer this sets.
final RtdbClient client;
/// The keystore holding the passphrase and the cached key.
final FlutterSecureStorage storage;
/// Argon2id cost for a header this device creates.
final Argon2Params params;
/// Why the last [unlock] stayed locked; null once open.
E2eState? last;
/// True while the client needs a key and has none (nothing is sent).
/// A client built without `sealRequired` (tests, fixtures) never locks.
bool get locked => client.sealRequired && client.sealer == null;
/// Opens the key (header made on first use); true when unlocked.
///
/// The crdt_sync log copy inside `openEncryptedStore` finds nothing to
/// copy here ([E2eHeaderStore] lists no directory): a relay tree is
/// not a crdt log; the PC worker copies the old root itself.
Future<bool> unlock() async {
if (!locked) return true;
final state = await openEncryptedStoreFromKeystore(
store: E2eHeaderStore(client),
oldPrefix: client.layout.base,
storage: storage,
params: params,
);
last = state;
if (state is E2eReady) {
client.sealer = RelaySealer(
state.store.key.cipher(),
layout: client.layout,
);
return true;
}
return false;
}
/// The lock reason of the last attempt, for the spoken label.
String get reason => switch (last) {
E2eLocked(:final reason) => reason.name,
_ => '',
};
}
/// Just enough of crdt_sync's [RemoteStore] for the e2e header: one JSON
/// string leaf (`<base>/e2e`, e.g. `tutor/e2e`), as the PC worker writes it.
class E2eHeaderStore implements RemoteStore {
/// Creates the store over [_client] (no sealing outside the e2e root).
new(this._client);
final RtdbClient _client;
@override
Future<String?> getFileText(String path) async {
final value = await _client.get(path);
if (value == null || value is String) return value as String?;
// Not a header we wrote: unlock reports badHeader, never overwrites it.
return '$value';
}
@override
Future<void> putFileText(
String path,
String text, {
required String message,
}) async {
await _client.put(path, text);
}
@override
Future<List<String>> listDirectory(String path) async => const [];
@override
Future<void> deleteFile(String path, {String message = ''}) =>
throw RemoteSyncError('the relay never deletes the e2e header');
@override
Future<bool> canAccessRemote() async => true;
@override
void close() {}
}

View File

@ -0,0 +1,59 @@
/// Applies RTDB stream events to a local copy of the listened subtree.
///
/// Pure and copy-on-write: callers keep the previous tree, so a listener can
/// diff old against new without the tree changing under it.
library;
import 'package:rtdb_relay/src/rtdb_event.dart';
List<String> _segments(String path) =>
path.split('/').where((s) => s.isNotEmpty).toList();
/// Returns [root] with [value] set at [path] (`/` replaces the root).
/// A null [value] deletes; maps left empty collapse to null, as in RTDB.
Object? setAt(Object? root, String path, Object? value) =>
_set(root, _segments(path), value);
Object? _set(Object? node, List<String> segs, Object? value) {
if (segs.isEmpty) return value;
final map = node is Map<String, dynamic>
? Map<String, dynamic>.of(node)
: <String, dynamic>{};
final child = _set(map[segs.first], segs.sublist(1), value);
if (child == null) {
map.remove(segs.first);
} else {
map[segs.first] = child;
}
return map.isEmpty ? null : map;
}
/// Reads the value at [path] in [root]; null when absent.
Object? getAt(Object? root, String path) {
var node = root;
for (final seg in _segments(path)) {
if (node is! Map<String, dynamic>) return null;
node = node[seg];
}
return node;
}
/// Applies one stream event; non-data events return [root] unchanged.
Object? applyEvent(Object? root, RtdbEvent event) {
switch (event) {
case RtdbPut(:final path, :final data):
return setAt(root, path, data);
case RtdbPatch(:final path, :final data):
var next = root;
for (final entry in data.entries) {
next = setAt(next, '$path/${entry.key}', entry.value);
}
return next;
case RtdbConnected():
case RtdbDisconnected():
case RtdbKeepAlive():
case RtdbCancel():
case RtdbAuthRevoked():
return root;
}
}

View File

@ -0,0 +1,148 @@
/// Which RTDB nodes are sealed, and how (the Dart twin of
/// `rtdb_relay/layout.py`).
///
/// Keys stay clear; every *unit* (a node one writer writes whole) is stored
/// as `{"_e2e": <blob>, <clear siblings>}`. A `clear` pattern covers its whole
/// subtree; a unit pattern maps to the fields it keeps clear (server
/// timestamps). `*` matches one segment. A write the layout has no rule for
/// throws: nothing new leaks by accident.
library;
import 'package:crdt_sync/crdt_sync.dart' show E2eLayout;
/// The key a sealed unit keeps its blob under.
const String kSealedKey = '_e2e';
/// The rules every relay app needs: request leases are clear, requests,
/// results and worker presence are sealed units.
const List<String> kRelayClear = ['requests/*/claim'];
/// The relay's own units and the fields each keeps clear.
const Map<String, Set<String>> kRelayUnits = {
'presence/workers/*': {'beat'},
'requests/*/req': {'created'},
'requests/*/result': {'at'},
};
/// A write the layout refuses (unknown path, or inside a sealed unit).
class E2eLayoutError implements Exception {
/// Creates the error.
const new(this.message);
/// What was refused.
final String message;
@override
String toString() => 'E2eLayoutError: $message';
}
/// Where a node falls in the layout.
enum E2eRuleKind {
/// Stored as is (ids, counters, lease times).
clear,
/// Sealed whole.
unit,
/// Inside a unit: never written on its own.
below,
/// A map of clear keys above units.
struct,
/// No rule: refused on write.
unknown,
}
/// The rule for one node.
class E2eRule {
/// Creates the rule.
const new(this.kind, [this.depth = 0, this.keep = const {}]);
/// Its kind.
final E2eRuleKind kind;
/// For [E2eRuleKind.below]: how many segments the unit has.
final int depth;
/// For a unit: the fields kept clear.
final Set<String> keep;
}
/// [path]'s segments, empty ones dropped.
List<String> e2eParts(String path) =>
path.split('/').where((s) => s.isNotEmpty).toList();
bool _matches(List<String> pattern, List<String> parts) {
if (pattern.length != parts.length) return false;
for (var i = 0; i < parts.length; i++) {
if (pattern[i] != '*' && pattern[i] != parts[i]) return false;
}
return true;
}
/// One app's sealed tree: its root and its rules.
class RelayLayout {
/// The layout for app root [base] (e.g. `tutor/v1`); the sealed tree lives
/// at crdt_sync's e2e prefix of it (`tutor/v1-e2e`). Pattern order matters:
/// the first matching rule wins, clear before units.
new(this.base, {required this.clear, required this.units})
: root = E2eLayout.of(base).prefix;
/// The pre-e2e root; the key header hangs off it (crdt_sync).
final String base;
/// The e2e root every relative path hangs off.
final String root;
/// Clear subtrees.
final List<String> clear;
/// Sealed units and the fields each keeps clear.
final Map<String, Set<String>> units;
/// The rule for the node at [parts] (relative to [root]).
E2eRule classify(List<String> parts) {
for (final pattern in clear) {
final pat = pattern.split('/');
if (pat.length <= parts.length &&
_matches(pat, parts.sublist(0, pat.length))) {
return const E2eRule(E2eRuleKind.clear);
}
}
for (final entry in units.entries) {
final pat = entry.key.split('/');
if (_matches(pat, parts)) {
return E2eRule(E2eRuleKind.unit, pat.length, entry.value);
}
if (pat.length < parts.length &&
_matches(pat, parts.sublist(0, pat.length))) {
return E2eRule(E2eRuleKind.below, pat.length, entry.value);
}
}
for (final pattern in [...clear, ...units.keys]) {
final pat = pattern.split('/');
if (parts.length < pat.length &&
_matches(pat.sublist(0, parts.length), parts)) {
return const E2eRule(E2eRuleKind.struct);
}
}
return const E2eRule(E2eRuleKind.unknown);
}
/// The sealed unit [rel] lies strictly below, or null.
String? unitPath(String rel) {
final parts = e2eParts(rel);
final rule = classify(parts);
return rule.kind == E2eRuleKind.below
? parts.sublist(0, rule.depth).join('/')
: null;
}
/// [path] relative to [root], or null when outside it.
String? rel(String path) {
final clean = e2eParts(path).join('/');
if (clean == root) return '';
return clean.startsWith('$root/') ? clean.substring(root.length + 1) : null;
}
}

View File

@ -0,0 +1,124 @@
/// Every request in flight, followed over ONE listen (tutor DOCS-contract
/// §4, §9).
///
/// RTDB speaks HTTP/1.1, so a browser holds at most 6 connections to it and
/// every listen keeps one for good. A listen per request let a Home request
/// still running under a Session turn take the app to 6 and starve the next
/// write. One `requests` listen ranged from the oldest followed rid
/// (`orderBy="$key"&startAt`: ULIDs sort by time) serves them all; another
/// device's request in that window rides along, unread.
///
/// `inFlight` counts the requests followed; the shared `rev` listen yields
/// to it (`rev_watcher.dart`), so requests and `rev` share one connection.
/// A request's PUT goes out before its follow starts, while `rev` may still
/// be open: 4 streams and the PUT, 1 connection to spare.
library;
import 'dart:async';
import 'package:flutter/foundation.dart';
import 'package:rtdb_relay/src/json_tree.dart';
import 'package:rtdb_relay/src/rtdb_client.dart' show keyRangeQuery;
import 'package:rtdb_relay/src/rtdb_event.dart';
import 'package:rtdb_relay/src/rtdb_stream.dart';
/// The shared `requests` listen.
class RequestHub {
/// Creates the hub over [_stream], following the requests node at
/// [requestsPath] (`<root>/requests`).
new(this._stream, this.requestsPath);
final RtdbStream _stream;
/// The full path of the requests node.
final String requestsPath;
/// Requests being followed; while above 0, `rev` waits.
final ValueNotifier<int> inFlight = ValueNotifier(0);
final Map<String, List<StreamController<Object?>>> _watchers = {};
// Cancelled in _close(); the lint cannot see across methods.
// ignore: cancel_subscriptions
StreamSubscription<RtdbEvent>? _sub;
String? _from;
Object? _tree;
/// The `requests/{rid}` node each time it changes (null while absent),
/// until the subscription is cancelled.
Stream<Object?> watch(String rid) {
late final StreamController<Object?> out;
out = StreamController<Object?>(
// `rev` lets go before this listen opens and comes back only after
// it closed, so the two never hold two connections at once.
onListen: () {
inFlight.value++;
_watchers.putIfAbsent(rid, () => []).add(out);
_cover(rid);
},
onCancel: () {
final list = _watchers[rid]!..remove(out);
if (list.isEmpty) _watchers.remove(rid);
if (_watchers.isEmpty) _close();
inFlight.value--;
},
);
return out.stream;
}
/// Makes the listen reach back to [rid]: reopened from it when it is
/// older than the range's start, else [rid]'s node so far is handed over.
void _cover(String rid) {
final from = _from;
if (from != null && from.compareTo(rid) <= 0) {
final node = getAt(_tree, rid);
if (node != null) _send(rid, node);
return;
}
_close();
_from = rid;
_sub = _stream
.listen(requestsPath, query: keyRangeQuery(rid))
.listen(_on, onDone: _ended);
}
// The transport gave up for good (rules `cancel`): every follow ends with
// no result, as its own listen's end did.
void _ended() {
_sub = null;
_from = null;
_tree = null;
for (final list in [..._watchers.values]) {
for (final out in [...list]) {
unawaited(out.close());
}
}
}
void _close() {
final sub = _sub;
_sub = null;
_from = null;
_tree = null;
unawaited(sub?.cancel());
}
void _on(RtdbEvent event) {
if (event is! RtdbPut && event is! RtdbPatch) return;
final before = _tree;
_tree = applyEvent(before, event);
// Copy-on-write: a node no event touched is the very same object.
final snapshot = event is RtdbPut && event.path == '/';
for (final rid in [..._watchers.keys]) {
final node = getAt(_tree, rid);
// A snapshot (each connect) answers every watcher, as a per-request
// listen did: absent means queued.
if (snapshot || !identical(node, getAt(before, rid))) _send(rid, node);
}
}
void _send(String rid, Object? node) {
for (final out in [...?_watchers[rid]]) {
out.add(node);
}
}
}

View File

@ -0,0 +1,161 @@
/// "Did X change?" from a `rev` node of counters (the tutor's
/// DOCS-contract §3, §9: `rev.catalog`, `rev.stats`).
///
/// One shared listen for every screen: each `changesOf(key)` is a broadcast
/// stream; the first listener of any opens the SSE and the last cancel
/// closes it. The listen also pauses while the app is hidden and resumes
/// when it is back in front.
///
/// While a request is in flight ([RevWatcher.new]'s `yieldTo` above 0) the
/// listen stays closed: RTDB speaks HTTP/1.1, every listen holds one of the
/// browser's 6 connections, and the request's own listen takes this one.
/// Nothing is lost: the snapshot on reopening emits any move made meanwhile.
///
/// Only real moves are emitted; the full snapshot every (re)connect resends
/// while a value is unchanged is not a move. A snapshot whose value *did*
/// change (the worker moved it while the app was hidden) is.
library;
import 'dart:async';
import 'package:flutter/foundation.dart';
import 'package:flutter/widgets.dart';
import 'package:rtdb_relay/src/json_tree.dart';
import 'package:rtdb_relay/src/rtdb_event.dart';
import 'package:rtdb_relay/src/rtdb_stream.dart';
/// Counter [key] of a `rev` tree; 0 when absent.
int revOf(Object? rev, String key) {
final value = rev is Map<String, dynamic> ? rev[key] : null;
return value is num ? value.toInt() : 0;
}
/// Whether the app counts as in front for [state] (null: not reported yet).
/// `inactive` keeps whatever was decided before: desktop web reports it on
/// a mere focus change, which is no reason to drop or reopen the listen.
bool? foregroundFor(AppLifecycleState? state) => switch (state) {
null || AppLifecycleState.resumed => true,
AppLifecycleState.inactive => null,
AppLifecycleState.hidden ||
AppLifecycleState.paused ||
AppLifecycleState.detached => false,
};
/// Streams `rev` while someone listens and the app is in front.
class RevWatcher {
/// Creates the watcher; `binding` (tests) reports the app lifecycle;
/// while [yieldTo] is above 0 the listen is closed.
/// [path] is the full path of the `rev` node.
new(this._stream, this.path, {this._binding, this.yieldTo}) {
yieldTo?.addListener(_yield);
}
final RtdbStream _stream;
final WidgetsBinding? _binding;
/// The full path of the `rev` node.
final String path;
/// Requests in flight (`RequestRelay.inFlight`).
final ValueListenable<int>? yieldTo;
bool get _yielding => (yieldTo?.value ?? 0) > 0;
final Map<String, StreamController<int>> _outs = {};
final Map<String, int> _last = {};
// Cancelled in _disconnect(); the lint cannot see across methods.
// ignore: cancel_subscriptions
StreamSubscription<RtdbEvent>? _sub;
AppLifecycleListener? _lifecycle;
bool _foreground = true;
Object? _tree;
/// The new `rev.<key>` each time it moves.
Stream<int> changesOf(String key) => _outs.putIfAbsent(key, () {
// A counter absent so far reads 0: its baseline once any event came.
if (_tree != null) _last.putIfAbsent(key, () => revOf(_tree, key));
return StreamController.broadcast(onListen: _open, onCancel: _release);
}).stream;
bool get _wanted => _outs.values.any((c) => c.hasListener);
/// Whether the SSE listen is open (tests).
bool get listening => _sub != null;
/// Tells the watcher the app went to the back (false) or front (true).
void foreground({required bool visible}) {
_foreground = visible;
visible ? _connect() : unawaited(_disconnect());
}
/// Closes the listen and the stream.
Future<void> dispose() async {
yieldTo?.removeListener(_yield);
for (final out in _outs.values) {
await out.close();
}
await _close();
}
// The first listener of either stream opens the listen, the last closes it.
void _open() {
if (_lifecycle != null) return;
final binding = _binding ?? WidgetsBinding.instance;
_foreground = foregroundFor(binding.lifecycleState) ?? true;
_lifecycle = AppLifecycleListener(
binding: binding,
onStateChange: (state) {
final visible = foregroundFor(state);
if (visible != null) foreground(visible: visible);
},
);
_connect();
}
Future<void> _release() async {
if (!_wanted) await _close();
}
Future<void> _close() async {
_lifecycle?.dispose();
_lifecycle = null;
await _disconnect();
}
void _yield() => _yielding ? unawaited(_disconnect()) : _connect();
void _connect() {
if (_sub != null || !_foreground || !_wanted || _yielding) return;
_tree = null;
_sub = _stream.listen(path).listen(_on, onDone: () => _sub = null);
}
Future<void> _disconnect() async {
final sub = _sub;
_sub = null;
await sub?.cancel();
}
void _on(RtdbEvent event) {
if (event is RtdbConnected) _tree = null;
if (event is! RtdbPut && event is! RtdbPatch) return;
final tree = _tree = applyEvent(_tree, event);
// Every counter keeps a baseline, watched or not, so a stream opened
// later still sees only real moves.
final keys = {
if (tree is Map<String, dynamic>) ...tree.keys,
..._outs.keys,
};
for (final key in keys) {
final now = revOf(tree, key);
final before = _last[key];
_last[key] = now;
// The first value ever is the baseline the screens loaded against.
final out = _outs[key];
if (before != null && before != now && out != null && !out.isClosed) {
out.add(now);
}
}
}
}

View File

@ -0,0 +1,220 @@
/// Firebase Realtime Database over REST, with ETag conditional writes.
///
/// crdt_sync's `FirebaseRestClient` stores only string leaves, so the relay
/// keeps its own GET/PUT/PATCH/DELETE. Every request carries
/// `?auth=<idToken>`; the token source refreshes it.
///
/// Under the layout's e2e root (e.g. `tutor/v1-e2e`) every value passes
/// through `sealer` (sealed on write, opened on read). With `sealRequired`
/// (the app) a call there before the key is unlocked throws instead of
/// sending plaintext.
library;
import 'dart:convert';
import 'package:crdt_sync/crdt_sync.dart'
show checkSyncNamespace, syncNamespace;
import 'package:http/http.dart' as http;
import 'package:rtdb_relay/src/layout.dart';
import 'package:rtdb_relay/src/rtdb_types.dart';
import 'package:rtdb_relay/src/sealer.dart';
export 'package:rtdb_relay/src/rtdb_types.dart';
/// The REST client.
class RtdbClient {
/// Creates a client for [databaseUrl] authenticated by [idToken].
///
/// [namespace] (default: the `SYNC_NAMESPACE` dart-define, as in crdt_sync)
/// is empty for production or `sandbox/<slot>`; every request path then
/// lives under `/<namespace>/`. Anything else throws (fail closed).
new({
required this.layout,
required String databaseUrl,
required this.idToken,
http.Client? httpClient,
String? namespace,
this.sealer,
this.sealRequired = false,
}) : _namespace = checkSyncNamespace(namespace ?? syncNamespace),
_base = databaseUrl.endsWith('/')
? databaseUrl.substring(0, databaseUrl.length - 1)
: databaseUrl,
_http = httpClient ?? http.Client();
/// The app's sealed tree.
final RelayLayout layout;
final String _base;
final String _namespace;
/// Token source; also used by the stream for reconnects.
final IdTokenSource idToken;
final http.Client _http;
/// The underlying HTTP client, shared with the SSE stream.
http.Client get httpClient => _http;
/// Seals and opens the e2e root; null until the key is unlocked.
RelaySealer? sealer;
/// When true, a call under the e2e root without [sealer] throws.
final bool sealRequired;
/// [path] relative to the e2e root, or null when outside it.
String? e2eRel(String path) => layout.rel(path);
RelaySealer? _sealerFor(String? rel) {
if (rel == null) return null;
if (sealer == null && sealRequired) {
throw const RtdbError('e2e locked: no key, nothing is sent');
}
return sealer;
}
/// [value] read at [path] with its sealed units opened.
Future<Object?> opened(String path, Object? value) async {
final rel = e2eRel(path);
final s = _sealerFor(rel);
return s == null ? value : await s.open(rel!, value);
}
Future<Object?> _sealed(String path, Object? value) async {
final rel = e2eRel(path);
final s = _sealerFor(rel);
return s == null ? value : await s.seal(rel!, value);
}
/// The REST URL of [path] with a fresh token and [query].
Future<Uri> uri(String path, {Map<String, String> query = const {}}) async {
final segments = [
..._namespace.split('/'),
...path.split('/'),
].where((s) => s.isNotEmpty);
final encoded = segments.map(Uri.encodeComponent).join('/');
return Uri.parse('$_base/$encoded.json')
.replace(queryParameters: {'auth': await idToken(), ...query});
}
/// Reads [path]; null when absent.
Future<Object?> get(
String path, {
Map<String, String> query = const {},
}) async {
final rel = e2eRel(path);
final unit = rel != null && _sealerFor(rel) != null
? layout.unitPath(rel)
: null;
if (unit != null) {
// Below a sealed unit: read the whole unit, open it, walk down.
var node = await get('${layout.root}/$unit');
for (final part in e2eParts(rel!).skip(e2eParts(unit).length)) {
node = node is Map ? node[part] : null;
}
return node;
}
final res = await _send('GET', path, query: query);
return await opened(path, _decode(res));
}
/// Keys directly under [path] (`shallow=true`, values not transferred).
Future<List<String>> keys(String path) async {
final value = await get(path, query: {'shallow': 'true'});
if (value is! Map) return const [];
return value.keys.cast<String>().toList()..sort();
}
/// Reads [path] with its ETag, for a following conditional write.
Future<Tagged> getTagged(String path) async {
final res = await _send('GET', path, headers: {'X-Firebase-ETag': 'true'});
return Tagged(await opened(path, _decode(res)), res.headers['etag'] ?? '');
}
/// Writes [value] at [path]; returns the stored value with server values
/// (`{".sv":"timestamp"}`) resolved.
Future<Object?> put(String path, Object? value) async => await opened(
path,
_decode(await _send('PUT', path, body: await _sealed(path, value))),
);
/// PUT only if the node still has [etag]; a 412 is a lost race.
Future<ConditionalResult> putIfMatch(
String path,
Object? value,
String etag,
) async =>
await _conditional('PUT', path, etag, body: await _sealed(path, value));
/// DELETE only if the node still has [etag].
Future<ConditionalResult> deleteIfMatch(String path, String etag) =>
_conditional('DELETE', path, etag);
/// Merges [values] into the map at [path] (no ETag support in RTDB).
Future<void> patch(String path, Map<String, Object?> values) async {
final rel = e2eRel(path);
final s = _sealerFor(rel);
final body = s == null ? values : await s.sealPatch(rel!, values);
await _send('PATCH', path, body: body);
}
/// Removes [path].
Future<void> delete(String path) async {
_sealerFor(e2eRel(path));
await _send('DELETE', path);
}
/// Releases the HTTP client.
void close() => _http.close();
Future<ConditionalResult> _conditional(
String method,
String path,
String etag, {
Object? body,
}) async {
final res = await _send(
method,
path,
body: body,
headers: {'if-match': etag},
accept412: true,
);
return ConditionalResult(
ok: res.statusCode != 412,
value: await opened(path, _decode(res)),
etag: res.headers['etag'],
);
}
Future<http.Response> _send(
String method,
String path, {
Object? body,
Map<String, String> query = const {},
Map<String, String> headers = const {},
bool accept412 = false,
}) async {
final request = http.Request(method, await uri(path, query: query))
..headers.addAll(headers);
if (method == 'PUT' || method == 'PATCH') {
request.body = jsonEncode(body);
}
final http.Response res;
try {
res = await http.Response.fromStream(await _http.send(request));
} on http.ClientException catch (exc) {
throw RtdbError('network error: $method $path: $exc');
}
final ok = res.statusCode >= 200 && res.statusCode < 300;
if (!ok && !(accept412 && res.statusCode == 412)) {
throw RtdbError(
'$method $path: HTTP ${res.statusCode} ${res.body.trim()}',
status: res.statusCode,
);
}
return res;
}
static Object? _decode(http.Response res) =>
res.body.isEmpty ? null : jsonDecode(res.body);
}

View File

@ -0,0 +1,142 @@
/// Server-sent events from the RTDB streaming API, parsed and typed.
///
/// Pure: no I/O, so every line-splitting and event-mapping edge is unit
/// tested without a socket. The transport lives in `rtdb_stream.dart`.
library;
import 'dart:convert';
/// One raw SSE frame: an `event:` name and its joined `data:` lines.
class SseFrame {
/// Creates the frame.
const new(this.event, this.data);
/// The `event:` field (`put`, `patch`, `keep-alive`, ...).
final String event;
/// The `data:` lines joined with `\n`.
final String data;
}
/// Splits a text stream into [SseFrame]s.
///
/// Feed decoded chunks in arrival order; a chunk may end mid-line or
/// mid-frame. A blank line dispatches the frame being built.
class SseParser {
String _buffer = '';
String _event = '';
final List<String> _data = [];
/// Adds [chunk] and returns the frames it completed.
List<SseFrame> add(String chunk) {
_buffer += chunk;
final frames = <SseFrame>[];
while (true) {
final newline = _buffer.indexOf('\n');
if (newline < 0) break;
var line = _buffer.substring(0, newline);
_buffer = _buffer.substring(newline + 1);
if (line.endsWith('\r')) line = line.substring(0, line.length - 1);
if (line.isEmpty) {
if (_event.isNotEmpty || _data.isNotEmpty) {
frames.add(SseFrame(_event, _data.join('\n')));
}
_event = '';
_data.clear();
} else if (line.startsWith('event:')) {
_event = line.substring(6).trim();
} else if (line.startsWith('data:')) {
_data.add(line.substring(5).trimLeft());
}
// Comments (":...") and unknown fields are ignored, as SSE requires.
}
return frames;
}
}
/// A typed RTDB stream event.
sealed class RtdbEvent {
const new();
/// Maps an SSE frame; null for frames the client ignores.
static RtdbEvent? fromFrame(SseFrame frame) {
switch (frame.event) {
case 'put':
case 'patch':
final body = jsonDecode(frame.data) as Map<String, dynamic>;
final path = body['path'] as String;
return frame.event == 'put'
? RtdbPut(path, body['data'])
: RtdbPatch(path, body['data'] as Map<String, dynamic>);
case 'keep-alive':
return const RtdbKeepAlive();
case 'cancel':
return RtdbCancel(frame.data);
case 'auth_revoked':
return const RtdbAuthRevoked();
}
return null;
}
}
/// Emitted by the transport before each (re)connect's snapshot `put`.
class RtdbConnected extends RtdbEvent {
/// Creates the marker.
const new();
}
/// Emitted by the transport when a connection drops or fails to open; it
/// reconnects on its own after a backoff.
class RtdbDisconnected extends RtdbEvent {
/// Creates the marker.
const new(this.error);
/// Why (an [Exception], an HTTP status error, or null for a clean end).
final Object? error;
}
/// `put`: [data] replaces the node at [path] (relative to the listened path;
/// `/` on connect is the full snapshot).
class RtdbPut extends RtdbEvent {
/// Creates the event.
const new(this.path, this.data);
/// Path relative to the listened location.
final String path;
/// New value (null deletes).
final Object? data;
}
/// `patch`: each child of [data] replaces that child under [path].
class RtdbPatch extends RtdbEvent {
/// Creates the event.
const new(this.path, this.data);
/// Path relative to the listened location.
final String path;
/// Children to replace.
final Map<String, dynamic> data;
}
/// The server's liveness ping (every ~30 s with no data).
class RtdbKeepAlive extends RtdbEvent {
/// Creates the event.
const new();
}
/// The rules no longer allow this listen; the stream ends.
class RtdbCancel extends RtdbEvent {
/// Creates the event.
const new(this.reason);
/// Server-provided reason text.
final String reason;
}
/// The token expired; the transport reconnects with a fresh one.
class RtdbAuthRevoked extends RtdbEvent {
/// Creates the event.
const new();
}

View File

@ -0,0 +1,211 @@
/// The RTDB streaming transport: one long-lived `text/event-stream` GET per
/// listened path, reconnecting until the listener cancels.
///
/// Every (re)connect resends the full snapshot of the path, so callers listen
/// narrowly (tutor DOCS-contract §9). `auth_revoked` reconnects at once with a
/// fresh token; network failures and clean ends back off 1 s .. 30 s;
/// `cancel` (rules changed) ends the stream for good.
///
/// RTDB speaks HTTP/1.1, so a browser holds at most 6 connections to it and
/// every listen is one. The app keeps at most 4 open, leaving 2 for writes
/// and reads (tutor DOCS-contract §9). A cancelled
/// listen therefore aborts its request, even one still connecting: a leaked
/// stream starved the next session's listens and the chat stayed empty after
/// Next card (2026-10-12).
library;
import 'dart:async';
import 'dart:convert';
import 'package:flutter/foundation.dart' show kIsWeb;
import 'package:http/http.dart' as http;
import 'package:rtdb_relay/src/rtdb_client.dart';
import 'package:rtdb_relay/src/rtdb_event.dart';
/// Waits [d]; injectable so tests run the reconnect loop without real time.
typedef Sleep = Future<void> Function(Duration d);
/// Backoff before reconnect attempt [n] (0-based): 1, 2, 4 .. 30 s.
Duration reconnectDelay(int n) => Duration(seconds: n >= 5 ? 30 : 1 << n);
enum _End { reconnectNow, backoff, stop }
/// Opens SSE listens through an [RtdbClient].
class RtdbStream {
/// Creates the transport.
new(this.client, {Sleep? sleep}) : _sleep = sleep ?? Future<void>.delayed;
/// Supplies URLs (with fresh tokens) and the HTTP client.
final RtdbClient client;
final Sleep _sleep;
/// Streams events for [path] until the subscription is cancelled.
Stream<RtdbEvent> listen(
String path, {
Map<String, String> query = const {},
}) {
late final StreamController<RtdbEvent> out;
StreamSubscription<String>? sub;
final abort = Completer<void>();
var stopped = false;
void emit(RtdbEvent event) {
if (!stopped && !out.isClosed) out.add(event);
}
// Sealed units open asynchronously; a chain keeps the events in order.
final sealed = client.e2eRel(path) != null;
var chain = Future<void>.value();
Future<_End> consume(http.StreamedResponse res) {
final done = Completer<_End>();
final parser = SseParser();
void finish(_End end) {
if (!done.isCompleted) done.complete(end);
}
sub = res.stream
.transform(utf8.decoder)
.listen(
(chunk) {
for (final frame in parser.add(chunk)) {
if (done.isCompleted) return;
final RtdbEvent? event;
try {
event = RtdbEvent.fromFrame(frame);
} on Object catch (error) {
// A malformed frame: drop the connection and resync from
// the next snapshot rather than apply half an update.
emit(RtdbDisconnected(error));
finish(_End.backoff);
return;
}
if (event == null) continue;
if (!sealed) {
emit(event);
} else {
final sealedEvent = event;
chain = chain.then((_) async {
try {
emit(await openEvent(client, path, sealedEvent));
} on Object catch (error) {
// Locked, or an event inside a unit: resync later.
emit(RtdbDisconnected(error));
finish(_End.backoff);
}
});
}
if (event is RtdbAuthRevoked) finish(_End.reconnectNow);
if (event is RtdbCancel) finish(_End.stop);
}
},
onError: (Object e) {
emit(RtdbDisconnected(e));
finish(_End.backoff);
},
onDone: () {
chain = chain.then((_) {
emit(const RtdbDisconnected(null));
finish(_End.backoff);
});
},
);
return done.future;
}
Future<void> run() async {
var attempt = 0;
while (!stopped) {
var end = _End.backoff;
try {
final res = await _open(
await client.uri(path, query: query),
abort.future,
);
if (stopped) {
// Cancelled while connecting: let go of the response too.
await res.stream.listen(null).cancel();
break;
}
attempt = 0;
emit(const RtdbConnected());
end = await consume(res);
await sub?.cancel();
} on Object catch (error) {
// `on Object`: a token failure is a FirebaseAuthError, a bad frame
// a FormatException, a dropped socket a ClientException; all of
// them mean "try again later", never "crash the listener".
emit(RtdbDisconnected(error));
}
if (end == _End.stop || stopped) break;
if (end == _End.backoff) await _sleep(reconnectDelay(attempt++));
}
if (!out.isClosed) await out.close();
}
out = StreamController<RtdbEvent>(
onListen: () => unawaited(run()),
onCancel: () async {
stopped = true;
if (!abort.isCompleted) abort.complete();
await sub?.cancel();
},
);
return out.stream;
}
/// GET with `Accept: text/event-stream`, following redirects by hand so
/// the Accept header survives a 307 to another RTDB host.
Future<http.StreamedResponse> _open(Uri uri, Future<void> abort) async {
var target = uri;
for (var hop = 0; hop < 5; hop++) {
final request = http.AbortableRequest('GET', target, abortTrigger: abort)
// A browser's fetch cannot hand a redirect back (http's
// BrowserClient raises instead) and follows it keeping Accept, so
// only the VM follows by hand.
..followRedirects = kIsWeb
..headers['Accept'] = 'text/event-stream';
final res = await client.httpClient.send(request);
final location = res.headers['location'];
if (res.statusCode >= 300 && res.statusCode < 400 && location != null) {
await res.stream.drain<void>();
target = target.resolve(location);
continue;
}
if (res.statusCode != 200) {
final body = await res.stream.bytesToString();
throw RtdbError(
'stream ${uri.path}: HTTP ${res.statusCode} ${body.trim()}',
status: res.statusCode,
);
}
return res;
}
throw RtdbError('stream ${uri.path}: too many redirects');
}
}
/// [event] (from a listen on [listened]) with its sealed units opened.
Future<RtdbEvent> openEvent(
RtdbClient client,
String listened,
RtdbEvent event,
) async {
String at(String rel) => [
listened,
rel,
].expand((p) => p.split('/')).where((s) => s.isNotEmpty).join('/');
switch (event) {
case RtdbPut():
return RtdbPut(
event.path,
await client.opened(at(event.path), event.data),
);
case RtdbPatch():
return RtdbPatch(event.path, {
for (final e in event.data.entries)
e.key: await client.opened(at('${event.path}/${e.key}'), e.value),
});
default:
return event;
}
}

View File

@ -0,0 +1,65 @@
/// The REST client's value types: token source, errors, ETag pairs and the
/// `$key` range query.
library;
import 'dart:convert';
/// Supplies a currently valid Firebase ID token.
typedef IdTokenSource = Future<String> Function();
/// A failed RTDB request. [status] is null for network failures.
class RtdbError implements Exception {
/// Creates the error.
const new(this.message, {this.status});
/// What failed, with the HTTP body when there was one.
final String message;
/// HTTP status, or null when the request never got an answer.
final int? status;
/// True when the rules or the token rejected this request (401/403).
bool get isAuth => status == 401 || status == 403;
/// True when retrying the same request can succeed (network, 5xx).
bool get isTransient => status == null || status! >= 500;
@override
String toString() => 'RtdbError($status): $message';
}
/// A value read together with the ETag a conditional write must match.
class Tagged {
/// Creates the pair.
const new(this.value, this.etag);
/// The decoded JSON value (null when the node is absent).
final Object? value;
/// The opaque ETag of [value].
final String etag;
}
/// Result of a conditional PUT/DELETE.
class ConditionalResult {
/// Creates the result.
const new({required this.ok, required this.value, required this.etag});
/// False on 412: another writer won the race.
final bool ok;
/// The written value (server values resolved), or the current one on 412.
final Object? value;
/// ETag of [value] after the call, when the server sent one.
final String? etag;
}
/// Query parameters for a `$key`-ordered read starting at [startAt].
///
/// RTDB wants both values JSON-quoted. Only `orderBy="$key"` is usable:
/// the shared rules add no `.indexOn`.
Map<String, String> keyRangeQuery(String startAt) => {
'orderBy': jsonEncode(r'$key'),
'startAt': jsonEncode(startAt),
};

View File

@ -0,0 +1,151 @@
/// Seals writes and opens reads of one app's tree (the Dart twin of
/// `rtdb_relay/seal.py`): each unit becomes crdt_sync's [E2eCipher] blob
/// with the unit's full path as AAD, so a blob moved elsewhere does not open.
library;
import 'dart:convert';
import 'package:crdt_sync/crdt_sync.dart' show E2eCipher;
import 'package:rtdb_relay/src/layout.dart';
Object? _pruned(Object? value) {
if (value is! Map) return value;
final out = <String, Object?>{};
for (final e in value.entries) {
final v = _pruned(e.value);
if (v != null) out[e.key as String] = v;
}
return out.isEmpty ? null : out;
}
/// Seals writes and opens reads under [root] with [cipher].
class RelaySealer {
/// Creates the sealer for [layout]; [root] overrides its e2e root.
new(this.cipher, {required this.layout, String? root})
: root = root ?? layout.root;
/// The tree rules.
final RelayLayout layout;
/// The key's cipher.
final E2eCipher cipher;
/// The e2e root every relative path hangs off.
final String root;
String _aad(List<String> parts) => [root, ...parts].join('/');
/// [value] as it may be stored at [rel]; throws [E2eLayoutError] for an
/// unknown path.
Future<Object?> seal(String rel, Object? value) =>
_seal(e2eParts(rel), value);
/// A PATCH body for [rel]: each (multi-segment) key sealed on its own.
Future<Map<String, Object?>> sealPatch(
String rel,
Map<String, Object?> body,
) async {
final base = e2eParts(rel);
final kind = layout.classify(base).kind;
if (kind == E2eRuleKind.unit || kind == E2eRuleKind.below) {
throw E2eLayoutError('PATCH into sealed unit $rel');
}
return {
for (final e in body.entries)
e.key: await _seal([...base, ...e2eParts(e.key)], e.value),
};
}
Future<Object?> _seal(List<String> parts, Object? value) async {
final rule = layout.classify(parts);
if (rule.kind == E2eRuleKind.clear || value == null) return value;
if (rule.kind == E2eRuleKind.unit) {
return await _sealUnit(parts, value, rule.keep);
}
if (rule.kind == E2eRuleKind.struct && value is Map) {
return {
for (final e in value.entries)
e.key as String: await _seal([
...parts,
...e2eParts(e.key as String),
], e.value),
};
}
throw E2eLayoutError(
'no e2e rule for a ${value.runtimeType} at ${parts.join('/')} '
'(${rule.kind.name})',
);
}
Future<Map<String, Object?>?> _sealUnit(
List<String> parts,
Object raw,
Set<String> keep,
) async {
// As RTDB would keep it: no null members, no empty objects.
final value = _pruned(raw);
if (value == null) return null;
var body = value;
final clear = <String, Object?>{};
if (value is Map && keep.isNotEmpty) {
body = {
for (final e in value.entries)
if (!keep.contains(e.key)) e.key as String: e.value,
};
for (final e in value.entries) {
if (keep.contains(e.key)) clear[e.key as String] = e.value;
}
}
final blob = await cipher.seal(jsonEncode(body), path: _aad(parts));
return {kSealedKey: blob, ...clear};
}
/// [value] read at [rel] with every unit in it opened. A unit that does
/// not open reads as absent; legacy plaintext is returned as stored.
Future<Object?> open(String rel, Object? value) =>
_open(e2eParts(rel), value);
Future<Object?> _open(List<String> parts, Object? value) async {
final rule = layout.classify(parts);
switch (rule.kind) {
case E2eRuleKind.unit:
return await _openUnit(parts, value);
case E2eRuleKind.below:
throw E2eLayoutError('read below sealed unit: ${parts.join('/')}');
case E2eRuleKind.struct when value is Map:
final out = <String, Object?>{};
for (final e in value.entries) {
final v = await _open([...parts, e.key as String], e.value);
if (v != null) out[e.key as String] = v;
}
return out;
case E2eRuleKind.struct when value is List:
return [
for (var i = 0; i < value.length; i++)
await _open([...parts, '$i'], value[i]),
];
case _:
return value;
}
}
Future<Object?> _openUnit(List<String> parts, Object? value) async {
if (value is! Map || value[kSealedKey] is! String) return value;
try {
final text = await cipher.open(
value[kSealedKey] as String,
path: _aad(parts),
);
final data = jsonDecode(text);
if (data is! Map) return data;
return <String, Object?>{
...data.cast<String, Object?>(),
for (final e in value.entries)
if (e.key != kSealedKey) e.key as String: e.value,
};
} on FormatException {
// E2eDecryptError is one: tampered, moved, or another key.
return null;
}
}
}

View File

@ -0,0 +1,72 @@
/// Desktop sign-in without Google in the browser (todo's pattern).
///
/// The desktop app is the web build in a Chrome `--app` window, served by the
/// app's PC server (e.g. the tutor's). Google Identity Services cannot sign in
/// programmatically there, and nothing outside the Chrome profile can write its
/// storage. So the server hands the page the PC's own seeded session (e.g.
/// `~/.config/tutor/firebase_auth.json`, written by crdt-sync's
/// `link_google.py`) ONCE, at `<app>/sync-credentials`, and the page keeps it
/// in its own credential store from then on.
library;
import 'dart:convert';
import 'dart:developer';
import 'package:crdt_sync/crdt_sync.dart'
show FirebaseCredentialStore, FirebaseCredentials;
import 'package:http/http.dart' as http;
/// Route, relative to the app's base URL (`/app/sync-credentials`).
const kSyncCredentialsRoute = 'sync-credentials';
/// The Firebase uid inside [idToken] (JWT `user_id`, else `sub`), or null.
String? uidOfIdToken(String idToken) {
final parts = idToken.split('.');
if (parts.length != 3) return null;
try {
final payload = jsonDecode(
utf8.decode(base64Url.decode(base64Url.normalize(parts[1]))),
);
if (payload is! Map<String, dynamic>) return null;
final uid = payload['user_id'] ?? payload['sub'];
return uid is String ? uid : null;
} on FormatException {
return null;
}
}
/// Fetches the seeded session from the wrapper at [base] and saves it into
/// [store]. True when adopted. Refuses a session for any uid but
/// [expectedUid]: adopting bypasses the sign-in's wrong-account guard, so
/// the same check is made here.
Future<bool> adoptWrapperCredentials({
required Uri base,
required http.Client client,
required FirebaseCredentialStore store,
required String expectedUid,
}) async {
try {
final res = await client.get(base.resolve(kSyncCredentialsRoute));
if (res.statusCode != 200) return false;
final body = jsonDecode(utf8.decode(res.bodyBytes));
if (body is! Map<String, dynamic> ||
body['id_token'] is! String ||
body['refresh_token'] is! String ||
body['expires_at'] is! String) {
log('wrapper credentials malformed; not adopted', level: 900);
return false;
}
final uid = uidOfIdToken(body['id_token'] as String);
if (uid != expectedUid) {
log('wrapper credentials are for another account', level: 1000);
return false;
}
await store.save(FirebaseCredentials.fromJson(body));
return true;
} on Object catch (error) {
// `on Object`: no wrapper at all (Android: `Uri.base` is file:///, an
// ArgumentError) or a network error both mean "not adopted".
log('wrapper credentials unavailable', level: 800, error: error);
return false;
}
}

View File

@ -0,0 +1,698 @@
# Generated by pub
# See https://dart.dev/tools/pub/glossary#lockfile
packages:
args:
dependency: transitive
description:
name: args
sha256: d0481093c50b1da8910eb0bb301626d4d8eb7284aa739614d2b394ee09e3ea04
url: "https://pub.dev"
source: hosted
version: "2.7.0"
async:
dependency: transitive
description:
name: async
sha256: e2eb0491ba5ddb6177742d2da23904574082139b07c1e33b8503b9f46f3e1a37
url: "https://pub.dev"
source: hosted
version: "2.13.1"
boolean_selector:
dependency: transitive
description:
name: boolean_selector
sha256: "8aab1771e1243a5063b8b0ff68042d67334e3feab9e95b9490f9a6ebf73b42ea"
url: "https://pub.dev"
source: hosted
version: "2.1.2"
characters:
dependency: transitive
description:
name: characters
sha256: faf38497bda5ead2a8c7615f4f7939df04333478bf32e4173fcb06d428b5716b
url: "https://pub.dev"
source: hosted
version: "1.4.1"
clock:
dependency: transitive
description:
name: clock
sha256: e51d50bca3217c9a9fa2b41a30e4a38971133f5f9ec7a3d57bae095007f1d28e
url: "https://pub.dev"
source: hosted
version: "1.1.3"
code_assets:
dependency: transitive
description:
name: code_assets
sha256: "1ef22a0be3af9370bd9481ac76db114db92bfe75d5ca2b2d7bc911764478a4d9"
url: "https://pub.dev"
source: hosted
version: "2.2.0"
collection:
dependency: transitive
description:
name: collection
sha256: "2f5709ae4d3d59dd8f7cd309b4e023046b57d8a6c82130785d2b0e5868084e76"
url: "https://pub.dev"
source: hosted
version: "1.19.1"
crdt_sync:
dependency: "direct main"
description:
path: crdt_sync_dart
ref: "crdt_sync_dart-v0.14.1"
resolved-ref: edd0f7a7882cb1d3904932ba94faa282d08165df
url: "https://github.com/kuhyx/utils"
source: git
version: "0.14.1"
crdt_sync_flutter:
dependency: "direct main"
description:
path: crdt_sync_flutter
ref: "crdt_sync_flutter-v0.8.2"
resolved-ref: "1962d303336dfe260850466b8ee841033b9ad1ce"
url: "https://github.com/kuhyx/utils"
source: git
version: "0.8.2"
crypto:
dependency: transitive
description:
name: crypto
sha256: e3626ae6270383c9e3a549f34c9e4cd26c09ae6a9adaab2bf4737a00340efdc4
url: "https://pub.dev"
source: hosted
version: "3.0.8"
cryptography:
dependency: transitive
description:
name: cryptography
sha256: "3eda3029d34ec9095a27a198ac9785630fe525c0eb6a49f3d575272f8e792ef0"
url: "https://pub.dev"
source: hosted
version: "2.9.0"
cupertino_ui:
dependency: transitive
description:
name: cupertino_ui
sha256: c3eaf7f5bdfee36deb0b14a4cbf7602f1b6b8d8b8576b81f38fc08c25881c94c
url: "https://pub.dev"
source: hosted
version: "1.1.7"
fake_async:
dependency: "direct dev"
description:
name: fake_async
sha256: "5368f224a74523e8d2e7399ea1638b37aecfca824a3cc4dfdf77bf1fa905ac44"
url: "https://pub.dev"
source: hosted
version: "1.3.3"
ffi:
dependency: transitive
description:
name: ffi
sha256: "6d7fd89431262d8f3125e81b50d3847a091d846eafcd4fdb88dd06f36d705a45"
url: "https://pub.dev"
source: hosted
version: "2.2.0"
ffi_leak_tracker:
dependency: transitive
description:
name: ffi_leak_tracker
sha256: "4093d4ef9ca06ffe2786e73bfb25e22aa92112b9bb4ec941f11e3e6b61489a97"
url: "https://pub.dev"
source: hosted
version: "0.1.2"
file:
dependency: transitive
description:
name: file
sha256: a3b4f84adafef897088c160faf7dfffb7696046cb13ae90b508c2cbc95d3b8d4
url: "https://pub.dev"
source: hosted
version: "7.0.1"
fixnum:
dependency: transitive
description:
name: fixnum
sha256: b6dc7065e46c974bc7c5f143080a6764ec7a4be6da1285ececdc37be96de53be
url: "https://pub.dev"
source: hosted
version: "1.1.1"
flutter:
dependency: "direct main"
description: flutter
source: sdk
version: "0.0.0"
flutter_localizations:
dependency: transitive
description: flutter
source: sdk
version: "0.0.0"
flutter_secure_storage:
dependency: "direct main"
description:
name: flutter_secure_storage
sha256: d4e1fb6b2cb524868929e78dc0282fa000554b22060fb53789dc481c9fc95bb8
url: "https://pub.dev"
source: hosted
version: "11.2.0"
flutter_secure_storage_darwin:
dependency: transitive
description:
name: flutter_secure_storage_darwin
sha256: a031ceac9b070e62ef183cd7f7d1a8798ebde402d5049f0fe6eb3a51bd797a21
url: "https://pub.dev"
source: hosted
version: "0.4.3"
flutter_secure_storage_linux:
dependency: transitive
description:
name: flutter_secure_storage_linux
sha256: caa75bd78f017422912e3a904933113b2428eb79f981ac37acd2dd2a700458ea
url: "https://pub.dev"
source: hosted
version: "3.0.3"
flutter_secure_storage_platform_interface:
dependency: transitive
description:
name: flutter_secure_storage_platform_interface
sha256: "64951127f001f546891c86f414972bf49ef2c4c8a4c92c65f5790cc0c9100045"
url: "https://pub.dev"
source: hosted
version: "2.1.1"
flutter_secure_storage_web:
dependency: transitive
description:
name: flutter_secure_storage_web
sha256: "073a62b3aeb866ab4ce795f960413948e51e5a42a9b0c8333b6daf5bb3208a1c"
url: "https://pub.dev"
source: hosted
version: "2.1.1"
flutter_secure_storage_windows:
dependency: transitive
description:
name: flutter_secure_storage_windows
sha256: "471951813a97006d899db4948acc654a4f28c440083ea08178935ce20b173ec1"
url: "https://pub.dev"
source: hosted
version: "4.2.2"
flutter_test:
dependency: "direct dev"
description: flutter
source: sdk
version: "0.0.0"
flutter_web_plugins:
dependency: transitive
description: flutter
source: sdk
version: "0.0.0"
google_account_token:
dependency: transitive
description:
path: google_account_token
ref: "google_account_token-v0.1.0"
resolved-ref: db70ba204d124c6eadf9b8808cd3d3b3e70363d1
url: "https://github.com/kuhyx/utils"
source: git
version: "0.1.0"
hooks:
dependency: transitive
description:
name: hooks
sha256: eaac480a35ec0814146c2c48d96aaa829e0e44a7662c88ae84c9edf4bc35651f
url: "https://pub.dev"
source: hosted
version: "2.2.0"
http:
dependency: "direct main"
description:
name: http
sha256: "87721a4a50b19c7f1d49001e51409bddc46303966ce89a65af4f4e6004896412"
url: "https://pub.dev"
source: hosted
version: "1.6.0"
http_parser:
dependency: transitive
description:
name: http_parser
sha256: "178d74305e7866013777bab2c3d8726205dc5a4dd935297175b19a23a2e66571"
url: "https://pub.dev"
source: hosted
version: "4.1.2"
intl:
dependency: transitive
description:
name: intl
sha256: "1ca20c894b1717686a2319b8548763d812bc0aabdac580420a44c5178c57a867"
url: "https://pub.dev"
source: hosted
version: "0.20.3"
jni:
dependency: transitive
description:
name: jni
sha256: "2e91e6087291affd10b31b6c872f3e3ac7dc5d93b51b5ba485d930c8f08bde6c"
url: "https://pub.dev"
source: hosted
version: "1.1.2"
jni_flutter:
dependency: transitive
description:
name: jni_flutter
sha256: "0dd33d67797560f66e961a6053882d4df54bd345bf063b8fe7ea133f7ad8b191"
url: "https://pub.dev"
source: hosted
version: "1.0.4+1"
jni_util:
dependency: transitive
description:
name: jni_util
sha256: "1ba86da04a5f2bf18fde2edb235587e70c5b0fc5bd4ba955f46b00942c3fc35f"
url: "https://pub.dev"
source: hosted
version: "1.0.0"
leak_tracker:
dependency: transitive
description:
name: leak_tracker
sha256: "33e2e26bdd85a0112ec15400c8cbffea70d0f9c3407491f672a2fad47915e2de"
url: "https://pub.dev"
source: hosted
version: "11.0.2"
leak_tracker_flutter_testing:
dependency: transitive
description:
name: leak_tracker_flutter_testing
sha256: "1dbc140bb5a23c75ea9c4811222756104fbcd1a27173f0c34ca01e16bea473c1"
url: "https://pub.dev"
source: hosted
version: "3.0.10"
leak_tracker_testing:
dependency: transitive
description:
name: leak_tracker_testing
sha256: "8d5a2d49f4a66b49744b23b018848400d23e54caf9463f4eb20df3eb8acb2eb1"
url: "https://pub.dev"
source: hosted
version: "3.0.2"
listen:
dependency: transitive
description:
name: listen
sha256: "47501a08016a43fcad79252439d723f50f14f88fa7bfd8a177e0a417e5c9e1f2"
url: "https://pub.dev"
source: hosted
version: "1.0.1"
logging:
dependency: transitive
description:
name: logging
sha256: c8245ada5f1717ed44271ed1c26b8ce85ca3228fd2ffdb75468ab01979309d61
url: "https://pub.dev"
source: hosted
version: "1.3.0"
matcher:
dependency: transitive
description:
name: matcher
sha256: "31bd099b47c10cd1aeb55146a2d46ce0277630ecef3f7dae54ad7873f36696cd"
url: "https://pub.dev"
source: hosted
version: "0.12.20"
material_color_utilities:
dependency: transitive
description:
name: material_color_utilities
sha256: "9c337007e82b1889149c82ed242ed1cb24a66044e30979c44912381e9be4c48b"
url: "https://pub.dev"
source: hosted
version: "0.13.0"
material_ui:
dependency: transitive
description:
name: material_ui
sha256: "474c135fd46b56ff1d35ca982155e8863d28fbc6464d1192acf4ee53a738680e"
url: "https://pub.dev"
source: hosted
version: "1.11.0"
meta:
dependency: transitive
description:
name: meta
sha256: "307249ce4ff29d58a18e97f6345f539382eb9c9c29ecda628900f31de0443dd9"
url: "https://pub.dev"
source: hosted
version: "1.19.0"
objective_c:
dependency: transitive
description:
name: objective_c
sha256: c965d264fd4b0b4dd402dce9d049b70656bf98d3ca108b9bc55d2544ceadbe5e
url: "https://pub.dev"
source: hosted
version: "9.6.4"
package_config:
dependency: transitive
description:
name: package_config
sha256: ffcf4cf3d6c0b74ac43708d9f56625506e8a68aa935abe9d267a7330f320eb5d
url: "https://pub.dev"
source: hosted
version: "3.0.0"
path:
dependency: transitive
description:
name: path
sha256: "75cca69d1490965be98c73ceaea117e8a04dd21217b37b292c9ddbec0d955bc5"
url: "https://pub.dev"
source: hosted
version: "1.9.1"
path_provider:
dependency: transitive
description:
name: path_provider
sha256: a7f4874f987173da295a61c181b8ee71dab59b332a486b391babf26a1b884825
url: "https://pub.dev"
source: hosted
version: "2.1.6"
path_provider_android:
dependency: transitive
description:
name: path_provider_android
sha256: "69cbd515a62b94d32a7944f086b2f82b4ac40a1d45bebfc00813a430ab2dabcd"
url: "https://pub.dev"
source: hosted
version: "2.3.1"
path_provider_foundation:
dependency: transitive
description:
name: path_provider_foundation
sha256: "2a376b7d6392d80cd3705782d2caa734ca4727776db0b6ec36ef3f1855197699"
url: "https://pub.dev"
source: hosted
version: "2.6.0"
path_provider_linux:
dependency: transitive
description:
name: path_provider_linux
sha256: "58c2005f147315b11e9b4a7bc889cd5203e250cba8e3f012dae259b4972b5c16"
url: "https://pub.dev"
source: hosted
version: "2.2.2"
path_provider_platform_interface:
dependency: transitive
description:
name: path_provider_platform_interface
sha256: "484838772624c3a4b94f1e44a3e19897fee738f2d5c4ce448443b0417f7c9dda"
url: "https://pub.dev"
source: hosted
version: "2.1.3"
path_provider_windows:
dependency: transitive
description:
name: path_provider_windows
sha256: bd6f00dbd873bfb70d0761682da2b3a2c2fccc2b9e84c495821639601d81afe7
url: "https://pub.dev"
source: hosted
version: "2.3.0"
platform:
dependency: transitive
description:
name: platform
sha256: a36d119c13416516a7b5913fbe8af8531e11633d784c550b2125f76c758524ec
url: "https://pub.dev"
source: hosted
version: "3.2.0"
plugin_platform_interface:
dependency: transitive
description:
name: plugin_platform_interface
sha256: "4820fbfdb9478b1ebae27888254d445073732dae3d6ea81f0b7e06d5dedc3f02"
url: "https://pub.dev"
source: hosted
version: "2.1.8"
pub_semver:
dependency: transitive
description:
name: pub_semver
sha256: "261236774e8b1d69cfc6b9eabbc96c40f25e7a2d6b171f3385d4f65d5734fb24"
url: "https://pub.dev"
source: hosted
version: "2.2.1"
record_use:
dependency: transitive
description:
name: record_use
sha256: "1cb8564af8d43b464294411db9217f5ec04891c6f22ee2c32d73ae05e88a6bd2"
url: "https://pub.dev"
source: hosted
version: "1.1.1"
shared_preferences:
dependency: transitive
description:
name: shared_preferences
sha256: "1e85e0dccf5b4a016077fea7dfbb4a7cb39c759ac1596fcf60c06deadb7da91f"
url: "https://pub.dev"
source: hosted
version: "2.5.6"
shared_preferences_android:
dependency: transitive
description:
name: shared_preferences_android
sha256: "137dedccacb394b8f470d6c9b435ffc3d33faaa6ce2949c4f54a61007d64396d"
url: "https://pub.dev"
source: hosted
version: "2.5.5"
shared_preferences_foundation:
dependency: transitive
description:
name: shared_preferences_foundation
sha256: "89435cb71ecb1ad1bf29ef73a381f871a06f433d4182b7e2ba7243b02b2c544b"
url: "https://pub.dev"
source: hosted
version: "2.6.2"
shared_preferences_linux:
dependency: transitive
description:
name: shared_preferences_linux
sha256: "580abfd40f415611503cae30adf626e6656dfb2f0cee8f465ece7b6defb40f2f"
url: "https://pub.dev"
source: hosted
version: "2.4.1"
shared_preferences_platform_interface:
dependency: transitive
description:
name: shared_preferences_platform_interface
sha256: "649dc798a33931919ea356c4305c2d1f81619ea6e92244070b520187b5140ef9"
url: "https://pub.dev"
source: hosted
version: "2.4.2"
shared_preferences_web:
dependency: transitive
description:
name: shared_preferences_web
sha256: c49bd060261c9a3f0ff445892695d6212ff603ef3115edbb448509d407600019
url: "https://pub.dev"
source: hosted
version: "2.4.3"
shared_preferences_windows:
dependency: transitive
description:
name: shared_preferences_windows
sha256: "94ef0f72b2d71bc3e700e025db3710911bd51a71cefb65cc609dd0d9a982e3c1"
url: "https://pub.dev"
source: hosted
version: "2.4.1"
sky_engine:
dependency: transitive
description: flutter
source: sdk
version: "0.0.0"
source_span:
dependency: transitive
description:
name: source_span
sha256: "56a02f1f4cd1a2d96303c0144c93bd6d909eea6bee6bf5a0e0b685edbd4c47ab"
url: "https://pub.dev"
source: hosted
version: "1.10.2"
stack_trace:
dependency: transitive
description:
name: stack_trace
sha256: "277654b3034d17ac6f9f1cb5595db011b1d5d41e8806866db28e0abaa101c490"
url: "https://pub.dev"
source: hosted
version: "1.12.2"
stream_channel:
dependency: transitive
description:
name: stream_channel
sha256: "969e04c80b8bcdf826f8f16579c7b14d780458bd97f56d107d3950fdbeef059d"
url: "https://pub.dev"
source: hosted
version: "2.1.4"
string_scanner:
dependency: transitive
description:
name: string_scanner
sha256: "921cd31725b72fe181906c6a94d987c78e3b98c2e205b397ea399d4054872b43"
url: "https://pub.dev"
source: hosted
version: "1.4.1"
term_glyph:
dependency: transitive
description:
name: term_glyph
sha256: "7f554798625ea768a7518313e58f83891c7f5024f88e46e7182a4558850a4b8e"
url: "https://pub.dev"
source: hosted
version: "1.2.2"
test_api:
dependency: transitive
description:
name: test_api
sha256: "0a10344e901e5b2e63819567951cb6a06673ed6b84f40462188ff5a0c41f371f"
url: "https://pub.dev"
source: hosted
version: "0.7.14"
typed_data:
dependency: transitive
description:
name: typed_data
sha256: f9049c039ebfeb4cf7a7104a675823cd72dba8297f264b6637062516699fa006
url: "https://pub.dev"
source: hosted
version: "1.4.0"
url_launcher:
dependency: transitive
description:
name: url_launcher
sha256: e8cc955c97e06df9879140a1fe301f3d493f01b7c62dec7f46834be31d7e9fda
url: "https://pub.dev"
source: hosted
version: "6.3.3"
url_launcher_android:
dependency: transitive
description:
name: url_launcher_android
sha256: b8073b1e5173d63afe1a18985a75896d72f759d3bc1817eb1ae8d26e8527cceb
url: "https://pub.dev"
source: hosted
version: "6.3.35"
url_launcher_ios:
dependency: transitive
description:
name: url_launcher_ios
sha256: "8faa1aab294f1ab4040b43660c887b0418d5fa4f0cffef76a484e6aa1092eb4a"
url: "https://pub.dev"
source: hosted
version: "6.4.2"
url_launcher_linux:
dependency: transitive
description:
name: url_launcher_linux
sha256: "10f86fef4c2c43563fa6c211ff9cf757adf4d3ab762c56bd430664a947d70cd0"
url: "https://pub.dev"
source: hosted
version: "3.2.3"
url_launcher_macos:
dependency: transitive
description:
name: url_launcher_macos
sha256: "5e835a3b869c2d70325349c81c5a45c28e20791265b67b2669da6b08c5cd5201"
url: "https://pub.dev"
source: hosted
version: "3.2.6"
url_launcher_platform_interface:
dependency: transitive
description:
name: url_launcher_platform_interface
sha256: "552f8a1e663569be95a8190206a38187b531910283c3e982193e4f2733f01029"
url: "https://pub.dev"
source: hosted
version: "2.3.2"
url_launcher_web:
dependency: transitive
description:
name: url_launcher_web
sha256: "85c81589622fbc87c1c683aaea164d3604a7777495a79d91e39ffcdec39ddb34"
url: "https://pub.dev"
source: hosted
version: "2.4.3"
url_launcher_windows:
dependency: transitive
description:
name: url_launcher_windows
sha256: "6c5ad3f22cd4c38e089b81963b3cd7bb83b111b2df5dce008bb066162f42e429"
url: "https://pub.dev"
source: hosted
version: "3.1.6"
uuid:
dependency: transitive
description:
name: uuid
sha256: "9b129329f58692f6e6578329498a8fe9fbe98f090beb764ffbb8ee2eadd01dcd"
url: "https://pub.dev"
source: hosted
version: "4.6.0"
vector_math:
dependency: transitive
description:
name: vector_math
sha256: fa49e1674cb84acb900141714e6c6e1f9ae099827c24d141430ff6819db4e1bc
url: "https://pub.dev"
source: hosted
version: "2.4.4"
very_good_analysis:
dependency: "direct dev"
description:
name: very_good_analysis
sha256: "0bd5eb8d6be76aa0d71e70cbdae6cac8f784f761170568e3c2214a6948c7f6d3"
url: "https://pub.dev"
source: hosted
version: "11.0.0"
vm_service:
dependency: transitive
description:
name: vm_service
sha256: "89b11d62e1040ee681af3b4f1c97a803ecbf010c6e8b9c5896ee5b08c3bf7b78"
url: "https://pub.dev"
source: hosted
version: "15.4.0"
web:
dependency: transitive
description:
name: web
sha256: e119e82ac4795c7925103b7cf3768191f33941b99e7ccffbd6c645201d9f606b
url: "https://pub.dev"
source: hosted
version: "1.1.2"
win32:
dependency: transitive
description:
name: win32
sha256: a0b93865d5644f11cf6a8c3f6db909f1ec168958b5805f6cc684adea957cd63d
url: "https://pub.dev"
source: hosted
version: "6.4.0"
xdg_directories:
dependency: transitive
description:
name: xdg_directories
sha256: "7a3f37b05d989967cdddcbb571f1ea834867ae2faa29725fd085180e0883aa15"
url: "https://pub.dev"
source: hosted
version: "1.1.0"
yaml:
dependency: transitive
description:
name: yaml
sha256: f67cdd8e07d3c6329146aaef1ba043542b3134c12489f553ca9a7435d1068aea
url: "https://pub.dev"
source: hosted
version: "3.1.4"
sdks:
dart: ">=3.13.5 <4.0.0"
flutter: ">=3.47.0"

View File

@ -0,0 +1,32 @@
name: rtdb_relay
description: >-
The Flutter client half of the sealed Firebase RTDB request relay (the PC
half is the Python rtdb_relay next to this directory). Extracted from the
tutor app; any app that talks to a PC worker over RTDB reuses it.
publish_to: 'none'
version: 0.2.0
environment:
sdk: ^3.13.5
dependencies:
crdt_sync:
git:
url: https://github.com/kuhyx/utils
ref: crdt_sync_dart-v0.14.1
path: crdt_sync_dart
crdt_sync_flutter:
git:
url: https://github.com/kuhyx/utils
ref: crdt_sync_flutter-v0.8.2
path: crdt_sync_flutter
flutter:
sdk: flutter
flutter_secure_storage: 11.2.0
http: 1.6.0
dev_dependencies:
fake_async: 1.3.3
flutter_test:
sdk: flutter
very_good_analysis: ^11.0.0

View File

@ -0,0 +1,32 @@
#!/bin/bash
# ============================================================================
# Fail if lcov line coverage drops below a threshold.
#
# Thin delegate to the shared gate in ~/src/utils/scripts, which owns the parsing
# and the threshold comparison. This file used to be a byte-identical copy of
# that logic; three such copies existed, which is how one package's idea of
# "covered" drifts from every other package's.
#
# Usage: check_coverage.sh <lcov.info> <min_percent>
# ============================================================================
set -euo pipefail
# Repo-relative, resolved from this script's own location: an absolute
# /home/... path exits 127 on an Actions runner.
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
readonly SCRIPT_DIR
readonly SHARED_GATE="${SCRIPT_DIR}/../../../scripts/check_coverage.sh"
main() {
if [[ ! -f "$SHARED_GATE" ]]; then
echo "Error: shared coverage gate not found at $SHARED_GATE" >&2
echo " It lives in the utils repo at scripts/check_coverage.sh." >&2
exit 1
fi
exec bash "$SHARED_GATE" "$@"
}
main "$@"

View File

@ -0,0 +1,103 @@
import 'dart:convert';
import 'package:crdt_sync/crdt_sync.dart'
show
FirebaseAuthError,
FirebaseCredentialStore,
FirebaseCredentials,
InMemoryCredentialStore;
import 'package:flutter_test/flutter_test.dart';
import 'package:http/http.dart' as http;
import 'package:http/testing.dart';
import 'package:rtdb_relay/src/auth.dart';
const _config = RelayFirebaseConfig(
apiKey: 'key',
databaseUrl: 'https://db',
syncUid: 'right-uid',
serverClientId: '',
);
MockClient _idp(String uid) => MockClient(
(_) async => http.Response(
jsonEncode({
'localId': uid,
'idToken': 'id-1',
'refreshToken': 'refresh-1',
'expiresIn': '3600',
}),
200,
),
);
class _BrokenStore extends InMemoryCredentialStore {
@override
Future<FirebaseCredentials?> load() => throw ArgumentError('Uri.base');
}
// The default sign-in: declines when no client id is compiled in.
Future<String?> _google({required String serverClientId}) async =>
serverClientId.isEmpty ? null : 'g';
RelayAuth _auth(FirebaseCredentialStore store, [http.Client? client]) =>
RelayAuth(
config: _config,
googleToken: _google,
store: store,
httpClient: client,
);
void main() {
test('right account: session stored, token served', () async {
final store = InMemoryCredentialStore();
final auth = _auth(store, _idp('right-uid'));
expect(await auth.hasSession(), isFalse);
final out = await auth.signInWithGoogle(tokenFetcher: () async => 'g');
expect(out, SignInOutcome.signedIn);
expect(await auth.hasSession(), isTrue);
expect(await auth.idToken(), 'id-1');
await auth.signOut();
expect(await store.load(), isNull);
});
test('wrong account throws and stores nothing', () async {
final store = InMemoryCredentialStore();
final auth = _auth(store, _idp('second-user'));
await expectLater(
auth.signInWithGoogle(tokenFetcher: () async => 'g'),
throwsA(isA<FirebaseAuthError>()),
);
expect(await store.load(), isNull);
});
test('cancelled picker and missing client id are not errors', () async {
final auth = _auth(InMemoryCredentialStore());
expect(
await auth.signInWithGoogle(tokenFetcher: () async => null),
SignInOutcome.cancelled,
);
// No client id compiled in: the default fetcher declines.
expect(await auth.signInWithGoogle(), SignInOutcome.cancelled);
});
test('a store that throws an Error reads as signed out', () async {
final auth = _auth(_BrokenStore());
expect(await auth.hasSession(), isFalse);
});
test('the adopt hook signs in a desktop with no session', () async {
final store = InMemoryCredentialStore();
var asked = 0;
final auth = RelayAuth(
config: _config,
googleToken: _google,
store: store,
adopt: () async {
asked++;
return false;
},
);
expect(await auth.hasSession(), isFalse);
expect(asked, 1);
});
}

View File

@ -0,0 +1,266 @@
{
"key_hex": "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
"root": "tutor/v1-e2e",
"sealed_key": "_e2e",
"rules": [
{
"path": "",
"kind": "struct"
},
{
"path": "meta",
"kind": "clear"
},
{
"path": "meta/min_client",
"kind": "clear"
},
{
"path": "rev",
"kind": "clear"
},
{
"path": "rev/catalog",
"kind": "clear"
},
{
"path": "live",
"kind": "unit"
},
{
"path": "prefs",
"kind": "struct"
},
{
"path": "prefs/current_subject",
"kind": "unit"
},
{
"path": "stats",
"kind": "struct"
},
{
"path": "stats/today",
"kind": "unit"
},
{
"path": "stats/today/new_cap",
"kind": "below"
},
{
"path": "presence/workers/d1",
"kind": "unit"
},
{
"path": "presence/clients/d1",
"kind": "unit"
},
{
"path": "uploads/u1/c0001",
"kind": "unit"
},
{
"path": "requests",
"kind": "struct"
},
{
"path": "requests/r1",
"kind": "struct"
},
{
"path": "requests/r1/req",
"kind": "unit"
},
{
"path": "requests/r1/claim",
"kind": "clear"
},
{
"path": "requests/r1/claim/by",
"kind": "clear"
},
{
"path": "requests/r1/result",
"kind": "unit"
},
{
"path": "sessions/s1",
"kind": "struct"
},
{
"path": "sessions/s1/meta",
"kind": "struct"
},
{
"path": "sessions/s1/meta/busy",
"kind": "unit"
},
{
"path": "sessions/s1/meta/busy/phase",
"kind": "below"
},
{
"path": "sessions/s1/msgs/m0001",
"kind": "unit"
},
{
"path": "sessions/s1/receipts/r0001",
"kind": "unit"
},
{
"path": "sessions/s1/user",
"kind": "struct"
},
{
"path": "sessions/s1/user/archived",
"kind": "unit"
},
{
"path": "sessions/s1/progress",
"kind": "struct"
},
{
"path": "sessions/s1/progress/rid",
"kind": "clear"
},
{
"path": "sessions/s1/progress/steps/s0001",
"kind": "unit"
},
{
"path": "session_index/s1",
"kind": "unit"
},
{
"path": "subjects/car/meta",
"kind": "unit"
},
{
"path": "subjects/car/meta/rev",
"kind": "below"
},
{
"path": "subjects/car/plan",
"kind": "unit"
},
{
"path": "subjects/car/cards",
"kind": "unit"
},
{
"path": "subjects/car/concepts",
"kind": "unit"
},
{
"path": "log/d1",
"kind": "struct"
},
{
"path": "log/d1/e1",
"kind": "unit"
},
{
"path": "feedback/f1",
"kind": "unit"
},
{
"path": "migration/v1_copied_at",
"kind": "clear"
},
{
"path": "secrets",
"kind": "unknown"
},
{
"path": "sessions/s1/other",
"kind": "unknown"
}
],
"units": [
{
"path": "requests/01J0000000000000000000000R/req",
"value": {
"kind": "message",
"dev": "d1",
"created": 1800000000000,
"sent_at": 1799999999000,
"body": {
"session": "20261012-170448-5b71",
"text": "zażółć gęślą jaźń"
}
},
"stored": {
"_e2e": "AVnxpT1g95cKDT1ORKsCeyjnBNJGfjyto/ezodv1ysIc2zHOmj77unCOLXQqYgQjvbfbNub710heso/QkMAUS5Mq+M5+/yIW56HevylofoiyPapWi7obYbu9otQwuOUeiQzutdJpQNw9x7dfUPLZAu1BRQoboIyCG0TrNH3X9LkBIRgWLHOpf3lxhmXGJht3muR4lS4zwDOxj7pB1lRluLM/mnJcXqzDdmgHHw==",
"created": 1800000000000
}
},
{
"path": "requests/01J0000000000000000000000R/result",
"value": {
"ok": true,
"at": 1800000000500,
"data": {
"msg": "m0002"
}
},
"stored": {
"_e2e": "AREDDVq3hgmR9xsL5pUrhSJbK+fBCm823Hx8oKUo+ExwPT342IvIEqu55Rog+u4wWXxON6Vy5xxJZwd4+gXfxkQ49j6cb+H0tyRO",
"at": 1800000000500
}
},
{
"path": "presence/clients/d1",
"value": {
"platform": "android",
"app": "1.0.0",
"seen": 1800000000000
},
"stored": {
"_e2e": "AYhbgKJJ4tsHmFB0THKTxQoCzwKOpa/3ioNcYmtj2UhmhRZyavA7614RT6y3aPAmBWf5uNhQgkKKOO+Qavw4XAad+7xttA23RB7Xhb0=",
"seen": 1800000000000
}
},
{
"path": "prefs/current_subject",
"value": "car",
"stored": {
"_e2e": "AWEy8u/msdxYHsp7PQ0jkzrYpdNP6SEqbJ0SUyqzT2DzoEpXRf+1vKAQVh1hUQ=="
}
},
{
"path": "sessions/20261012-170448-5b71/user/archived",
"value": true,
"stored": {
"_e2e": "AbS7aTNu+meRs1jvcw/alGgKKgbhV83VPihFMd8AmqW6QhwgCQMg46hnrJls"
}
},
{
"path": "log/d1/01J0000000000000000000000E",
"value": {
"type": "review",
"card": "ld-x",
"r": 3,
"t": 1800000000000
},
"stored": {
"_e2e": "ASqR1ybCH4+WKx7P0nihgr8IOcGMsw1fXXyigH7kgrAZHru4DX0lXW2cZF0DPwQxeay3dS36BYXPN6OgO8xnXjcTz3hUwjjlVLANzZvG0zICImA8rBDy5bInd/INDmc5"
}
}
],
"header": {
"path": "tutor/e2e",
"passphrase": "correct horse",
"text": "{\"v\":1,\"kdf\":\"argon2id\",\"salt\":\"67H6FMZ+zlSFuBRuMIy2IQ==\",\"m\":8,\"t\":1,\"p\":1,\"check\":\"JQdQLQiowhtNkztQDPtOOUARTzUStpsKZmPHGZXEJ/8=\"}",
"unit": {
"path": "log/0b6f2c1e-8f2a-4c1d-9e3b-7a5d4c3b2a10/01J0000000000000000000000E",
"value": {
"type": "review",
"card": "ld-x",
"r": 3
},
"stored": {
"_e2e": "ATvPPA3qI5F70kbmI3XDguYjUsmQZQD2j8fY85sGGOg5IcxeYQn4mbWichyVU82pQQ7WA1YDngEs0K17HImxMyJSUf2H622XzinCPSqN"
}
}
}
}

View File

@ -0,0 +1,113 @@
// Old vs new: the tutor's pre-extraction sealer (frozen copy) and the
// package's RelaySealer over the tutor layout must agree byte for byte, or
// the APK already on the phone stops reading what the new code writes.
import 'dart:convert';
import 'dart:math';
import 'dart:typed_data';
import 'package:crdt_sync/crdt_sync.dart' show E2eCipher;
import 'package:flutter_test/flutter_test.dart';
import 'package:rtdb_relay/src/layout.dart';
import 'package:rtdb_relay/src/sealer.dart';
import 'support/legacy_tutor_seal.dart' as old;
import 'support/tutor_layout.dart';
const _segments = [
'requests',
'req',
'result',
'claim',
'presence',
'workers',
'clients',
'sessions',
'meta',
'msgs',
'receipts',
'user',
'progress',
'steps',
'rid',
'subjects',
'plan',
'cards',
'concepts',
'log',
'feedback',
'uploads',
'live',
'prefs',
'stats',
'rev',
'migration',
'session_index',
'x',
'1',
];
List<String> _path(Random rng) => [
for (var i = 0, n = rng.nextInt(6); i < n; i++)
_segments[rng.nextInt(_segments.length)],
];
/// A sealable value for the unit at [parts]: a map holding its clear fields.
Object? _value(Random rng, Set<String> keep) => {
'n': rng.nextInt(1000),
'text': 'v${rng.nextInt(99)}',
for (final k in keep) k: rng.nextInt(1 << 30),
};
void main() {
final cipher = E2eCipher(
Uint8List.fromList(List.generate(32, (i) => i * 7 % 256)),
);
final before = old.TutorSealer(cipher);
final after = RelaySealer(cipher, layout: tutorLayout);
test('same root and the same rule for 20000 random paths', () {
expect(tutorLayout.root, old.kE2eLayout.prefix);
final rng = Random(20261117);
for (var i = 0; i < 20000; i++) {
final parts = _path(rng);
final a = old.classifyE2e(parts);
final b = tutorLayout.classify(parts);
expect(
[b.kind.name, b.depth, b.keep],
[a.kind.name, a.depth, a.keep],
reason: parts.join('/'),
);
expect(
tutorLayout.unitPath(parts.join('/')),
old.e2eUnitPath(parts.join('/')),
);
}
});
test(
'a unit sealed by either side opens on the other, identically',
() async {
final rng = Random(7);
var units = 0;
for (var i = 0; i < 40000 && units < 300; i++) {
final parts = _path(rng);
final rule = tutorLayout.classify(parts);
if (rule.kind != E2eRuleKind.unit) continue;
units++;
final rel = parts.join('/');
final value = _value(rng, rule.keep);
final sealedOld = await before.seal(rel, value);
final sealedNew = await after.seal(rel, value);
// Nonces differ; the clear siblings and the shape must not.
String strip(Object? v) => jsonEncode({
for (final e in (v! as Map).entries)
if (e.key != kSealedKey) e.key: e.value,
});
expect(strip(sealedNew), strip(sealedOld));
expect(await after.open(rel, sealedOld), value);
expect(await before.open(rel, sealedNew), value);
}
expect(units, 300);
},
);
}

View File

@ -0,0 +1,123 @@
import 'dart:convert';
import 'package:crdt_sync/crdt_sync.dart' show E2eLayout, E2eLockReason;
import 'package:crdt_sync_flutter/crdt_sync_flutter.dart'
show kE2ePassphraseKey;
import 'package:crdt_sync_flutter/testing/fake_secure_storage.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:rtdb_relay/src/e2e_gate.dart';
import 'package:rtdb_relay/src/json_tree.dart';
import 'package:rtdb_relay/src/layout.dart';
import 'package:rtdb_relay/src/rtdb_client.dart';
import 'support/e2e_fixture.dart';
import 'support/fake_rtdb.dart';
import 'support/tutor_layout.dart';
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
test('a client that needs a key sends nothing without one', () async {
final db = FakeRtdb();
final client = RtdbClient(
layout: tutorLayout,
databaseUrl: 'https://fake',
idToken: () async => 'tok',
httpClient: db.client().httpClient,
namespace: '',
sealRequired: true,
);
await expectLater(
client.put('tutor/v1-e2e/requests/$testRid/req', {'kind': 'x'}),
throwsA(isA<RtdbError>()),
);
await expectLater(
client.get('tutor/v1-e2e/live'),
throwsA(isA<RtdbError>()),
);
await expectLater(
client.delete('tutor/v1-e2e/live'),
throwsA(isA<RtdbError>()),
);
expect(db.log, isEmpty);
expect(E2eGate(client: client).locked, isTrue);
expect(E2eGate(client: db.client()).locked, isFalse);
expect(await E2eGate(client: db.client()).unlock(), isTrue);
});
group('E2eGate', () {
RtdbClient needy(FakeRtdb db) => RtdbClient(
layout: tutorLayout,
databaseUrl: 'https://fake',
idToken: () async => 'tok',
httpClient: db.client().httpClient,
namespace: '',
sealRequired: true,
);
test('unlocks from the keystore and makes the header once', () async {
installFakeSecureStorage(initial: {kE2ePassphraseKey: 'test-passphrase'});
final db = FakeRtdb();
final client = needy(db);
final gate = E2eGate(client: client, params: fastArgon);
expect(await gate.unlock(), isTrue);
expect(gate.locked, isFalse);
expect(await gate.unlock(), isTrue); // already open
final header = getAt(db.root, E2eLayout.of(tutorLayout.base).e2ePath);
expect(header, isA<String>());
await client.put('tutor/v1-e2e/live', {'session': 'x'});
expect(
jsonEncode(getAt(db.root, 'tutor/v1-e2e/live')),
contains(kSealedKey),
);
// A second device with the same passphrase reads the same key.
final other = needy(db);
expect(await E2eGate(client: other, params: fastArgon).unlock(), isTrue);
expect(await other.get('tutor/v1-e2e/live'), {'session': 'x'});
});
test('stays locked without, or with a wrong, passphrase', () async {
installFakeSecureStorage();
final db = FakeRtdb();
final gate = E2eGate(client: needy(db), params: fastArgon);
expect(await gate.unlock(), isFalse);
expect(gate.reason, E2eLockReason.needsPassphrase.name);
db.root = setAt(db.root, E2eLayout.of(tutorLayout.base).e2ePath, {
'not': 'a header',
});
installFakeSecureStorage(initial: {kE2ePassphraseKey: 'x'});
final bad = E2eGate(client: needy(db), params: fastArgon);
expect(await bad.unlock(), isFalse);
expect(bad.reason, E2eLockReason.badHeader.name);
});
test('opens a header and a unit the Python worker made', () async {
final h = e2eVectors['header'] as Map<String, dynamic>;
installFakeSecureStorage(
initial: {kE2ePassphraseKey: h['passphrase'] as String},
);
final db = FakeRtdb()..root = setAt(null, h['path'] as String, h['text']);
final unit = h['unit'] as Map<String, dynamic>;
db.root = setAt(db.root, 'tutor/v1-e2e/${unit['path']}', unit['stored']);
final client = needy(db);
expect(await E2eGate(client: client, params: fastArgon).unlock(), isTrue);
expect(await client.get('tutor/v1-e2e/${unit['path']}'), unit['value']);
installFakeSecureStorage(initial: {kE2ePassphraseKey: 'wrong'});
final wrong = E2eGate(client: needy(db), params: fastArgon);
expect(await wrong.unlock(), isFalse);
expect(wrong.reason, E2eLockReason.wrongKey.name);
});
});
test('the header store reads strings only and never deletes', () async {
final db = FakeRtdb()..root = setAt(null, 'tutor/e2e', {'x': 1});
final store = E2eHeaderStore(db.client());
expect(await store.getFileText('tutor/e2e'), '{x: 1}');
expect(await store.getFileText('tutor/none'), isNull);
expect(await store.listDirectory('tutor'), isEmpty);
expect(await store.canAccessRemote(), isTrue);
expect(() => store.deleteFile('tutor/e2e'), throwsA(anything));
store.close();
expect(const E2eLayoutError('x').toString(), 'E2eLayoutError: x');
});
}

View File

@ -0,0 +1,179 @@
import 'dart:async';
import 'dart:convert';
import 'package:flutter_test/flutter_test.dart';
import 'package:http/http.dart' as http;
import 'package:http/testing.dart';
import 'package:rtdb_relay/src/json_tree.dart';
import 'package:rtdb_relay/src/layout.dart';
import 'package:rtdb_relay/src/rtdb_client.dart';
import 'package:rtdb_relay/src/rtdb_event.dart';
import 'package:rtdb_relay/src/rtdb_stream.dart';
import 'support/e2e_fixture.dart';
import 'support/fake_rtdb.dart';
import 'support/tutor_layout.dart';
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
test(
'a pushed request is ciphertext at rest, read back in the clear',
() async {
final db = FakeRtdb();
final client = sealedClient(db);
final stored = await client.put('tutor/v1-e2e/requests/$testRid/req', {
'kind': 'message',
'dev': 'd1',
'created': {'.sv': 'timestamp'},
'body': {'session': '20261012-170448-5b71', 'text': 'secret words'},
});
final atRest = jsonEncode(db.root);
expect(atRest, isNot(contains('secret words')));
expect(atRest, isNot(contains('"text"')));
expect(atRest, isNot(contains('"kind"')));
// The server timestamp the credit maths needs stays clear and resolved.
expect(
getAt(db.root, '${'tutor/v1-e2e/requests/$testRid/req'}/created'),
db.serverTime,
);
expect((stored! as Map)['body'], {
'session': '20261012-170448-5b71',
'text': 'secret words',
});
final read = await client.get('tutor/v1-e2e/requests/$testRid') as Map?;
expect((read!['req'] as Map)['created'], db.serverTime);
expect(((read['req'] as Map)['body'] as Map)['text'], 'secret words');
},
);
test('the vectors pin the rules and open what Python sealed', () async {
expect(e2eVectors['root'], tutorLayout.root);
expect(e2eVectors['sealed_key'], kSealedKey);
for (final r
in (e2eVectors['rules'] as List).cast<Map<String, dynamic>>()) {
expect(
tutorLayout.classify(e2eParts(r['path'] as String)).kind.name,
r['kind'],
reason: r['path'] as String,
);
}
final s = vectorSealer();
for (final u
in (e2eVectors['units'] as List).cast<Map<String, dynamic>>()) {
final path = u['path'] as String;
expect(await s.open(path, u['stored']), u['value'], reason: path);
// And Dart's own seal round-trips through the same layout.
expect(await s.open(path, await s.seal(path, u['value'])), u['value']);
}
});
test('every path the app writes has a rule', () async {
final s = vectorSealer();
String rel(String p) => p.substring('tutor/v1-e2e'.length + 1);
final writes = <String, Object?>{
'tutor/v1-e2e/requests/$testRid/req': {'kind': 'x', 'created': 1},
'tutor/v1-e2e/feedback/$testRid': {'text': 'x'},
'tutor/v1-e2e/uploads/$testRid/c0001': 'aGVsbG8=',
'tutor/v1-e2e/log/0b6f2c1e-8f2a-4c1d-9e3b-7a5d4c3b2a10/$testRid': {
'r': 3,
},
'tutor/v1-e2e/prefs/current_subject': 'car',
'tutor/v1-e2e/presence/clients/0b6f2c1e-8f2a-4c1d-9e3b-7a5d4c3b2a10': {
'platform': 'web',
'seen': 1,
},
'tutor/v1-e2e/sessions/20261012-170448-5b71/user': {'archived': true},
};
for (final e in writes.entries) {
final sealed = await s.seal(rel(e.key), e.value);
expect(jsonEncode(sealed), contains(kSealedKey), reason: e.key);
expect(await s.open(rel(e.key), sealed), e.value, reason: e.key);
}
await expectLater(
s.seal('secrets', {'a': 1}),
throwsA(isA<E2eLayoutError>()),
);
await expectLater(
s.sealPatch('sessions/s/msgs/m0001', {'text': 'x'}),
throwsA(isA<E2eLayoutError>()),
);
await expectLater(
s.open('stats/today/x', 1),
throwsA(isA<E2eLayoutError>()),
);
expect(
await s.open('prefs', {
'current_subject': {kSealedKey: 'AQ=='},
'other': 'legacy',
}),
{'other': 'legacy'},
);
expect(await s.open('sessions', [1]), [1]);
expect(await s.seal('presence/clients/d', {'x': null}), isNull);
});
test('patch, tagged reads, below-unit reads and events open', () async {
final db = FakeRtdb();
final client = sealedClient(db);
const session = 'tutor/v1-e2e/sessions/20261012-170448-5b71';
await client.patch('$session/user', {'archived': true});
await client.put('tutor/v1-e2e/stats/today', {'new_cap': 25});
expect(jsonEncode(db.root), isNot(contains('new_cap')));
expect(await client.get('tutor/v1-e2e/stats/today/new_cap'), 25);
expect(await client.get('tutor/v1-e2e/stats/today/nope/x'), isNull);
expect((await client.getTagged('$session/user')).value, {'archived': true});
final put = await openEvent(
client,
session,
RtdbPut('/', getAt(db.root, session)),
);
expect((put as RtdbPut).data, {
'user': {'archived': true},
});
final patch = await openEvent(
client,
'tutor/v1-e2e/stats',
RtdbPatch('/', {'today': getAt(db.root, 'tutor/v1-e2e/stats/today')}),
);
expect((patch as RtdbPatch).data, {
'today': {'new_cap': 25},
});
expect(
await openEvent(client, session, const RtdbKeepAlive()),
isA<RtdbKeepAlive>(),
);
final cond = await client.putIfMatch('tutor/v1-e2e/stats/today', {
'n': 1,
}, 'x');
expect(cond.value, {'n': 1});
// Outside the e2e root nothing is sealed (the header lives there).
await client.put('tutor/e2e', 'header');
expect(getAt(db.root, 'tutor/e2e'), 'header');
});
test(
'a stream event inside a unit drops the connection, then resyncs',
() async {
final sse = StreamController<List<int>>();
final client = RtdbClient(
layout: tutorLayout,
databaseUrl: 'https://db',
idToken: () async => 'tok',
httpClient: MockClient.streaming(
(req, _) async => http.StreamedResponse(sse.stream, 200),
),
namespace: '',
)..sealer = vectorSealer();
final events = <RtdbEvent>[];
final sub = RtdbStream(
client,
sleep: (_) => Completer<void>().future,
).listen('tutor/v1-e2e/stats/today').listen(events.add);
sse.add(utf8.encode('event: put\ndata: {"path":"/x","data":1}\n\n'));
await pumpEventQueue();
expect(events.last, isA<RtdbDisconnected>());
await sub.cancel();
},
);
}

View File

@ -0,0 +1,137 @@
// Every request in flight shares one ranged `requests` listen.
import 'dart:async';
import 'package:flutter_test/flutter_test.dart';
import 'package:rtdb_relay/src/request_hub.dart';
import 'package:rtdb_relay/src/rtdb_event.dart';
import 'support/fake_stream.dart';
const _requests = 'tutor/v1-e2e/requests';
const _a = '01M4RBCX52MMHCK7K73E6KV910';
const _b = '01M4RBCX52MMHCK7K73E6KV911';
const _older = '01M4RBCX52MMHCK7K73E6KV900';
Future<void> _pump() => Future<void>.delayed(Duration.zero);
void main() {
late FakeStream stream;
late RequestHub hub;
setUp(() {
stream = FakeStream();
hub = RequestHub(stream, _requests);
});
test(
'two requests, one listen from the older rid; each sees its own',
() async {
final a = <Object?>[];
final b = <Object?>[];
final subA = hub.watch(_a).listen(a.add);
expect(hub.inFlight.value, 1);
expect(stream.openPaths, [_requests]);
expect(stream.queries[_requests]!['startAt'], '"$_a"');
final listen = stream.listens[_requests]!
..add(const RtdbConnected())
..add(const RtdbKeepAlive())
..add(
const RtdbPut('/', {
_a: {'req': 1},
}),
);
await _pump();
expect(a, [
{'req': 1},
]);
// A newer rid is inside the range already: no new listen, and what is
// known of it is handed over at once.
stream.emit('$_requests/$_b', const RtdbPut('/req', 2));
await _pump();
final subB = hub.watch(_b).listen(b.add);
await _pump();
expect(stream.listens[_requests], same(listen));
expect(stream.peak, 1);
expect(hub.inFlight.value, 2);
expect(b, [
{'req': 2},
]);
// An event for one request does not wake the other.
stream.emit('$_requests/$_b', const RtdbPut('/claim', 'w'));
await _pump();
expect(a, hasLength(1));
expect(b.last, {'req': 2, 'claim': 'w'});
// A reconnect's snapshot answers both.
listen.add(
const RtdbPut('/', {
_a: {'req': 1},
}),
);
await _pump();
expect(a, hasLength(2));
expect(b.last, isNull);
await subA.cancel();
expect(stream.openPaths, [_requests], reason: 'b still follows');
await subB.cancel();
expect(stream.openPaths, isEmpty);
expect(hub.inFlight.value, 0);
},
);
test('an older rid reopens the listen from it', () async {
final subA = hub.watch(_a).listen((_) {});
final first = stream.listens[_requests]!;
final old = <Object?>[];
final subOld = hub.watch(_older).listen(old.add);
expect(stream.listens[_requests], isNot(same(first)));
expect(first.hasListener, isFalse);
expect(stream.openPaths, [_requests]);
expect(stream.queries[_requests]!['startAt'], '"$_older"');
// Not yet heard: nothing handed over.
final subNone = hub.watch(_b).listen(old.add);
await _pump();
expect(old, isEmpty);
stream.emit('$_requests/$_older', const RtdbPut('/result', 'r'));
await _pump();
expect(old, [
{'result': 'r'},
]);
await subNone.cancel();
await subOld.cancel();
await subA.cancel();
expect(stream.openPaths, isEmpty);
expect(hub.inFlight.value, 0);
});
test('two watchers of the same rid both hear it', () async {
final got = <Object?>[];
final one = hub.watch(_a).listen(got.add);
final two = hub.watch(_a).listen(got.add);
stream.emit('$_requests/$_a', const RtdbPatch('/', {'claim': 'w'}));
await _pump();
expect(got, hasLength(2));
await one.cancel();
expect(stream.openPaths, [_requests]);
unawaited(two.cancel());
});
test('the listen ending for good ends every follow', () async {
var ended = 0;
hub.watch(_a).listen(null, onDone: () => ended++);
hub.watch(_b).listen(null, onDone: () => ended++);
await stream.listens[_requests]!.close();
await _pump();
expect(ended, 2);
expect(hub.inFlight.value, 0);
expect(stream.openPaths, isEmpty);
// The next follow opens a fresh listen.
final sub = hub.watch(_b).listen(null);
expect(stream.openPaths, [_requests]);
expect(stream.queries[_requests]!['startAt'], '"$_b"');
await sub.cancel();
});
}

View File

@ -0,0 +1,238 @@
import 'dart:async';
import 'package:flutter/widgets.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:rtdb_relay/src/rev_watcher.dart';
import 'package:rtdb_relay/src/rtdb_client.dart';
import 'package:rtdb_relay/src/rtdb_event.dart';
import 'package:rtdb_relay/src/rtdb_stream.dart';
class _FakeStream implements RtdbStream {
StreamController<RtdbEvent>? events;
final paths = <String>[];
@override
RtdbClient get client => throw UnimplementedError();
@override
Stream<RtdbEvent> listen(
String path, {
Map<String, String> query = const {},
}) {
paths.add(path);
return (events = StreamController<RtdbEvent>()).stream;
}
}
const _rev = 'tutor/v1-e2e/rev';
void main() {
final binding = TestWidgetsFlutterBinding.ensureInitialized();
setUp(
() => binding.handleAppLifecycleStateChanged(AppLifecycleState.resumed),
);
test('revOf and foregroundFor', () {
expect(revOf(null, 'catalog'), 0);
expect(revOf(const {'stats': 3}, 'catalog'), 0);
expect(revOf(const {'catalog': 'x'}, 'catalog'), 0);
expect(revOf(const {'catalog': 7.0}, 'catalog'), 7);
expect(foregroundFor(null), isTrue);
expect(foregroundFor(AppLifecycleState.resumed), isTrue);
expect(foregroundFor(AppLifecycleState.inactive), isNull);
for (final s in [
AppLifecycleState.hidden,
AppLifecycleState.paused,
AppLifecycleState.detached,
]) {
expect(foregroundFor(s), isFalse);
}
});
test(
'emits real catalog moves only; reconnect snapshots are ignored',
() async {
final s = _FakeStream();
final w = RevWatcher(s, _rev);
final seen = <int>[];
final sub = w.changesOf('catalog').listen(seen.add);
expect(s.paths, ['tutor/v1-e2e/rev']);
s.events!
..add(const RtdbConnected())
..add(const RtdbPut('/', {'catalog': 7, 'stats': 3}))
..add(const RtdbPatch('/', {'stats': 4}))
..add(const RtdbKeepAlive())
..add(const RtdbPut('/catalog', 8))
// A reconnect resends the whole node, unchanged: not a move.
..add(const RtdbDisconnected(null))
..add(const RtdbConnected())
..add(const RtdbPut('/', {'catalog': 8, 'stats': 4}))
..add(const RtdbPatch('/', {'catalog': 9}));
await pumpEventQueue();
expect(seen, [8, 9]);
await sub.cancel();
await w.dispose();
},
);
test(
'a key watched late keeps the baseline it had, absent reads 0',
() async {
final s = _FakeStream();
final w = RevWatcher(s, _rev);
final catalog = w.changesOf('catalog').listen((_) {});
s.events!.add(const RtdbPut('/', {'catalog': 1}));
await pumpEventQueue();
final stats = <int>[];
final late = w.changesOf('stats').listen(stats.add);
final todo = <int>[];
final fresh = w.changesOf('todo').listen(todo.add);
s.events!
..add(const RtdbPatch('/', {'stats': 2}))
..add(const RtdbPatch('/', {'catalog': 1}));
await pumpEventQueue();
expect(stats, [2]); // 0 -> 2 is a move
expect(todo, isEmpty);
await (catalog.cancel(), late.cancel(), fresh.cancel()).wait;
await w.dispose();
},
);
test(
'ref-counted: one listen for many screens, closed by the last',
() async {
final s = _FakeStream();
final w = RevWatcher(s, _rev);
final a = w.changesOf('catalog').listen((_) {});
final b = w.changesOf('catalog').listen((_) {});
expect(s.paths, hasLength(1));
await a.cancel();
expect(w.listening, isTrue);
await b.cancel();
expect(w.listening, isFalse);
expect(s.events!.hasListener, isFalse);
// The baseline survives: a move seen on the next listen is emitted.
final seen = <int>[];
final c = w.changesOf('catalog').listen(seen.add);
expect(s.paths, hasLength(2));
s.events!.add(const RtdbPut('/', {'catalog': 1}));
await pumpEventQueue();
expect(seen, isEmpty); // first value ever = baseline
await c.cancel();
await w.dispose();
},
);
test(
'pauses in the back, resumes in front; a missed move is emitted',
() async {
final s = _FakeStream();
// Without listeners, coming to the front opens nothing.
final w = RevWatcher(s, _rev)..foreground(visible: true);
expect(s.paths, isEmpty);
final seen = <int>[];
final sub = w.changesOf('catalog').listen(seen.add);
s.events!.add(const RtdbPut('/', {'catalog': 7}));
await pumpEventQueue();
final first = s.events!;
binding
..handleAppLifecycleStateChanged(AppLifecycleState.inactive)
..handleAppLifecycleStateChanged(AppLifecycleState.hidden);
await pumpEventQueue();
expect(w.listening, isFalse);
expect(first.hasListener, isFalse);
binding.handleAppLifecycleStateChanged(AppLifecycleState.inactive);
expect(w.listening, isFalse); // inactive alone decides nothing
binding.handleAppLifecycleStateChanged(AppLifecycleState.resumed);
expect(w.listening, isTrue);
expect(s.paths, hasLength(2));
s.events!
..add(const RtdbConnected())
..add(const RtdbPut('/', {'catalog': 9}));
await pumpEventQueue();
expect(seen, [9]);
// `cancel` ends the listen; the next return to the front reopens it.
await s.events!.close();
await pumpEventQueue();
expect(w.listening, isFalse);
w.foreground(visible: true);
expect(s.paths, hasLength(3));
await sub.cancel();
await w.dispose();
},
);
test('opened while hidden: waits for the front', () async {
binding
..handleAppLifecycleStateChanged(AppLifecycleState.inactive)
..handleAppLifecycleStateChanged(AppLifecycleState.hidden);
final s = _FakeStream();
final w = RevWatcher(s, _rev, binding: binding);
final sub = w.changesOf('catalog').listen((_) {});
expect(s.paths, isEmpty);
binding
..handleAppLifecycleStateChanged(AppLifecycleState.inactive)
..handleAppLifecycleStateChanged(AppLifecycleState.resumed);
expect(s.paths, hasLength(1));
await w.dispose();
await sub.cancel();
});
test('stats moves: one shared listen for both streams', () async {
final s = _FakeStream();
final w = RevWatcher(s, _rev, binding: binding);
final stats = <int>[];
final catalog = <int>[];
final a = w.changesOf('stats').listen(stats.add);
final b = w.changesOf('catalog').listen(catalog.add);
expect(s.paths, ['tutor/v1-e2e/rev']); // the second listener shares it
s.events!
..add(const RtdbPut('/', {'catalog': 1, 'stats': 4}))
..add(const RtdbPut('/', {'catalog': 1, 'stats': 4}))
..add(const RtdbPatch('/', {'stats': 5}));
await Future<void>.delayed(Duration.zero);
expect(stats, [5]);
expect(catalog, isEmpty);
await b.cancel();
expect(w.listening, isTrue); // stats still wants it
await a.cancel();
expect(w.listening, isFalse);
await w.dispose();
});
test(
'closed while a request is in flight; a move meanwhile is emitted',
() async {
final s = _FakeStream();
final inFlight = ValueNotifier(0);
final w = RevWatcher(s, _rev, yieldTo: inFlight);
final seen = <int>[];
final sub = w.changesOf('catalog').listen(seen.add);
s.events!
..add(const RtdbConnected())
..add(const RtdbPut('/', {'catalog': 3}));
await Future<void>.delayed(Duration.zero);
inFlight.value = 1;
expect(w.listening, isFalse);
expect(s.events!.hasListener, isFalse);
inFlight.value = 2; // a second request: still closed, no new listen
expect(s.paths, hasLength(1));
// In front again mid-request: stays closed.
w.foreground(visible: true);
expect(w.listening, isFalse);
inFlight.value = 0;
expect(w.listening, isTrue);
expect(s.paths, hasLength(2));
s.events!
..add(const RtdbConnected())
..add(const RtdbPut('/', {'catalog': 4}));
await Future<void>.delayed(Duration.zero);
expect(seen, [4]);
await sub.cancel();
await w.dispose();
inFlight.value = 1; // no longer heard
expect(s.paths, hasLength(2));
},
);
}

View File

@ -0,0 +1,140 @@
import 'dart:convert';
import 'package:flutter_test/flutter_test.dart';
import 'package:http/http.dart' as http;
import 'package:http/testing.dart';
import 'package:rtdb_relay/src/rtdb_client.dart';
import 'support/tutor_layout.dart';
RtdbClient _client(MockClientHandler handler, {String url = 'https://db/'}) =>
RtdbClient(
layout: tutorLayout,
databaseUrl: url,
idToken: () async => 'tok',
httpClient: MockClient(handler),
);
void main() {
test('uri encodes segments and carries the token and query', () async {
final c = _client((_) async => http.Response('null', 200));
final uri = await c.uri(
'/tutor/v1-e2e/a b/',
query: keyRangeQuery('m0003'),
);
expect(uri.path, '/tutor/v1-e2e/a%20b.json');
expect(uri.queryParameters['auth'], 'tok');
expect(uri.queryParameters['orderBy'], r'"$key"');
expect(uri.queryParameters['startAt'], '"m0003"');
final noSlash = RtdbClient(
layout: tutorLayout,
databaseUrl: 'https://x',
idToken: () async => 't',
);
expect((await noSlash.uri('a')).toString(), startsWith('https://x/a.json'));
noSlash.close();
});
test('get decodes JSON; empty body is null; keys are sorted', () async {
final c = _client((req) async {
if (req.url.queryParameters['shallow'] == 'true') {
return http.Response('{"b":true,"a":true}', 200);
}
return http.Response(req.url.path == '/e.json' ? '' : '{"x":1}', 200);
});
expect(await c.get('v'), {'x': 1});
expect(await c.get('e'), isNull);
expect(await c.keys('v'), ['a', 'b']);
});
test('keys of an absent node is empty', () async {
final c = _client((_) async => http.Response('null', 200));
expect(await c.keys('v'), isEmpty);
});
test('put sends JSON and returns the resolved body', () async {
late http.Request seen;
final c = _client((req) async {
seen = req;
return http.Response('{"created":123}', 200);
});
final out = await c.put('r', {
'created': {'.sv': 'timestamp'},
});
expect(seen.method, 'PUT');
expect(jsonDecode(seen.body), {
'created': {'.sv': 'timestamp'},
});
expect(out, {'created': 123});
});
test('getTagged asks for and returns the ETag', () async {
final c = _client((req) async {
expect(req.headers['X-Firebase-ETag'], 'true');
return http.Response('null', 200, headers: {'etag': 'E1'});
});
final t = await c.getTagged('claim');
expect(t.value, isNull);
expect(t.etag, 'E1');
final bare = _client((_) async => http.Response('1', 200));
expect((await bare.getTagged('x')).etag, '');
});
test('putIfMatch: success and 412 lost race', () async {
var status = 200;
final c = _client((req) async {
expect(req.headers['if-match'], 'E1');
return http.Response('{"by":"other"}', status, headers: {'etag': 'E2'});
});
final won = await c.putIfMatch('claim', {'by': 'me'}, 'E1');
expect(won.ok, isTrue);
status = 412;
final lost = await c.putIfMatch('claim', {'by': 'me'}, 'E1');
expect(lost.ok, isFalse);
expect(lost.value, {'by': 'other'});
expect(lost.etag, 'E2');
final del = await c.deleteIfMatch('claim', 'E1');
expect(del.ok, isFalse);
});
test('patch and delete use their methods', () async {
final methods = <String>[];
final c = _client((req) async {
methods.add(req.method);
return http.Response('null', 200);
});
await c.patch('p', {'a': 1});
await c.delete('p');
expect(methods, ['PATCH', 'DELETE']);
});
test('HTTP errors classify auth vs transient', () async {
var status = 401;
final c = _client((_) async => http.Response('{"error":"x"}', status));
final e401 = await c
.get('a')
.then<RtdbError?>((_) => null, onError: (Object e) => e as RtdbError);
expect(e401!.isAuth, isTrue);
expect(e401.isTransient, isFalse);
expect(e401.toString(), contains('401'));
status = 503;
await expectLater(
c.get('a'),
throwsA(isA<RtdbError>().having((e) => e.isTransient, 't', isTrue)),
);
status = 412;
await expectLater(c.put('a', 1), throwsA(isA<RtdbError>()));
});
test('network failure is a transient RtdbError', () async {
final c = _client((_) async => throw http.ClientException('down'));
await expectLater(
c.get('a'),
throwsA(
isA<RtdbError>()
.having((e) => e.status, 'status', isNull)
.having((e) => e.isTransient, 't', isTrue),
),
);
});
}

View File

@ -0,0 +1,91 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:rtdb_relay/src/json_tree.dart';
import 'package:rtdb_relay/src/rtdb_event.dart';
void main() {
group('SseParser', () {
test('frames split across chunks, CRLF, comments, multi-line data', () {
final p = SseParser();
expect(p.add('event: put\r\ndata: {"path":"/",'), isEmpty);
final frames = p.add('"data":1}\r\n\r\n: comment\nid: 1\n\n');
expect(frames, hasLength(1));
expect(frames.single.event, 'put');
expect(frames.single.data, '{"path":"/","data":1}');
final multi = p.add('event: x\ndata: a\ndata:b\n\n');
expect(multi.single.data, 'a\nb');
});
});
group('RtdbEvent.fromFrame', () {
test('put and patch', () {
final put =
RtdbEvent.fromFrame(
const SseFrame('put', '{"path":"/a","data":{"x":1}}'),
)!
as RtdbPut;
expect(put.path, '/a');
expect(put.data, {'x': 1});
final patch =
RtdbEvent.fromFrame(
const SseFrame('patch', '{"path":"/","data":{"b":2}}'),
)!
as RtdbPatch;
expect(patch.data, {'b': 2});
});
test('control events and unknown ones', () {
expect(
RtdbEvent.fromFrame(const SseFrame('keep-alive', 'null')),
isA<RtdbKeepAlive>(),
);
final cancel = RtdbEvent.fromFrame(const SseFrame('cancel', 'denied'));
expect((cancel! as RtdbCancel).reason, 'denied');
expect(
RtdbEvent.fromFrame(const SseFrame('auth_revoked', 'x')),
isA<RtdbAuthRevoked>(),
);
expect(RtdbEvent.fromFrame(const SseFrame('other', '')), isNull);
});
});
group('json tree', () {
test('put at root, nested put, delete collapses empty maps', () {
var t = applyEvent(null, const RtdbPut('/', {'a': 1}));
t = applyEvent(t, const RtdbPut('/b/c', 2));
expect(t, {
'a': 1,
'b': {'c': 2},
});
expect(getAt(t, 'b/c'), 2);
expect(getAt(t, 'a/x'), isNull);
t = applyEvent(t, const RtdbPut('/b/c', null));
expect(t, {'a': 1});
t = applyEvent(t, const RtdbPut('/a', null));
expect(t, isNull);
});
test('patch replaces each child; others untouched; non-data no-op', () {
final before = {
'w': {'x': 1, 'y': 2},
};
final after = applyEvent(before, const RtdbPatch('/w', {'x': 9, 'z': 3}));
expect(after, {
'w': {'x': 9, 'y': 2, 'z': 3},
});
expect(before['w'], {'x': 1, 'y': 2});
for (final e in const <RtdbEvent>[
RtdbConnected(),
RtdbDisconnected(null),
RtdbKeepAlive(),
RtdbCancel('r'),
RtdbAuthRevoked(),
]) {
expect(applyEvent(after, e), same(after));
}
});
test('a put under a scalar replaces it with a map', () {
expect(setAt(5, 'a', 1), {'a': 1});
});
});
}

View File

@ -0,0 +1,92 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:http/http.dart' as http;
import 'package:http/testing.dart';
import 'package:rtdb_relay/src/rtdb_client.dart';
import 'support/tutor_layout.dart';
/// Records every request the client sends.
class _Spy {
final seen = <http.Request>[];
RtdbClient client({String? namespace}) => RtdbClient(
layout: tutorLayout,
databaseUrl: 'https://db/',
idToken: () async => 'tok',
namespace: namespace,
httpClient: MockClient((req) async {
seen.add(req);
return http.Response('null', 200, headers: {'etag': 'e1'});
}),
);
}
void main() {
test('empty namespace keeps every path byte-identical', () async {
final spy = _Spy();
final c = spy.client(namespace: '');
await c.get('tutor/v1-e2e/a');
await c.put('/tutor/v1-e2e/b/', 1);
await c.patch('tutor/v1-e2e/c', {'k': 1});
await c.delete('tutor/v1-e2e/d');
await c.getTagged('tutor/v1-e2e/e');
await c.putIfMatch('tutor/v1-e2e/f', 1, 'e1');
await c.deleteIfMatch('tutor/v1-e2e/g', 'e1');
await c.keys('tutor/v1-e2e/h');
expect(spy.seen.map((r) => r.url.path), [
'/tutor/v1-e2e/a.json',
'/tutor/v1-e2e/b.json',
'/tutor/v1-e2e/c.json',
'/tutor/v1-e2e/d.json',
'/tutor/v1-e2e/e.json',
'/tutor/v1-e2e/f.json',
'/tutor/v1-e2e/g.json',
'/tutor/v1-e2e/h.json',
]);
});
test('a sandbox namespace prefixes every request path', () async {
final spy = _Spy();
final c = spy.client(namespace: 'sandbox/slot3');
await c.get('tutor/v1-e2e/a');
await c.put('/tutor/v1-e2e/b/', 1);
await c.patch('tutor/v1-e2e/c', {'k': 1});
await c.delete('tutor/v1-e2e/d');
await c.getTagged('tutor/v1-e2e/e');
await c.putIfMatch('tutor/v1-e2e/f', 1, 'e1');
await c.deleteIfMatch('tutor/v1-e2e/g', 'e1');
await c.keys('tutor/v1-e2e/h');
expect(
spy.seen.map((r) => r.url.path),
everyElement(startsWith('/sandbox/slot3/tutor/v1-e2e/')),
);
expect(spy.seen, hasLength(8));
});
test('uri (used by the SSE stream) is prefixed too', () async {
final c = _Spy().client(namespace: 'sandbox/slot3');
expect(
(await c.uri('tutor/v1-e2e/rev')).path,
'/sandbox/slot3/tutor/v1-e2e/rev.json',
);
});
test('an invalid namespace fails closed at construction', () {
for (final bad in [
'slot3',
'sandbox/',
'sandbox/Slot',
'prod',
'/x',
'sandbox/a/b',
'sandbox/s\n',
]) {
expect(() => _Spy().client(namespace: bad), throwsException, reason: bad);
}
});
test('the compiled define defaults to empty (production paths)', () async {
final c = _Spy().client();
expect((await c.uri('a')).path, '/a.json');
});
}

View File

@ -0,0 +1,195 @@
import 'dart:async';
import 'dart:convert';
import 'package:flutter_test/flutter_test.dart';
import 'package:http/http.dart' as http;
import 'package:http/testing.dart';
import 'package:rtdb_relay/src/rtdb_client.dart';
import 'package:rtdb_relay/src/rtdb_event.dart';
import 'package:rtdb_relay/src/rtdb_stream.dart';
import 'support/tutor_layout.dart';
/// Scripted server: each connection takes the next response factory.
class _Server {
final List<http.StreamedResponse Function(http.BaseRequest)> script = [];
final List<http.BaseRequest> requests = [];
final List<Duration> slept = [];
RtdbStream stream() {
final client = MockClient.streaming((req, _) async {
requests.add(req);
if (script.isEmpty) return _never();
return script.removeAt(0)(req);
});
return RtdbStream(
RtdbClient(
layout: tutorLayout,
databaseUrl: 'https://db',
idToken: () async => 'tok',
httpClient: client,
),
sleep: (d) async => slept.add(d),
);
}
}
http.StreamedResponse _sse(List<String> chunks, {bool close = true}) {
final c = StreamController<List<int>>();
for (final chunk in chunks) {
c.add(utf8.encode(chunk));
}
if (close) unawaited(c.close());
return http.StreamedResponse(c.stream, 200);
}
http.StreamedResponse _never() =>
http.StreamedResponse(StreamController<List<int>>().stream, 200);
String _frame(String event, String data) => 'event: $event\ndata: $data\n\n';
void main() {
test('reconnectDelay doubles to a 30 s cap', () {
expect(
[for (var i = 0; i < 7; i++) reconnectDelay(i).inSeconds],
[
1, 2, 4, 8, 16, 30, 30, //
],
);
});
test(
'snapshot, keep-alive, auth_revoked reconnects now, cancel ends',
() async {
final s = _Server()
..script.add(
(_) => _sse([
_frame('put', '{"path":"/","data":{"a":1}}'),
_frame('keep-alive', 'null'),
_frame('auth_revoked', 'credential is no longer valid'),
_frame('put', '{"path":"/late","data":1}'),
], close: false),
)
..script.add((_) => _sse([_frame('cancel', 'permission denied')]));
final events = await s.stream().listen('tutor/v1-e2e/presence').toList();
expect(events.map((e) => e.runtimeType).toList(), [
RtdbConnected,
RtdbPut,
RtdbKeepAlive,
RtdbAuthRevoked,
RtdbConnected,
RtdbCancel,
]);
expect(s.slept, isEmpty);
expect(s.requests.first.headers['Accept'], 'text/event-stream');
},
);
test('follows a 307 keeping Accept; HTTP error backs off', () async {
final s = _Server()
..script.add(
(_) => http.StreamedResponse(
const Stream.empty(),
307,
headers: {'location': 'https://other/x.json?auth=t'},
),
)
..script.add(
(_) => http.StreamedResponse(Stream.value(utf8.encode('no')), 401),
)
..script.add((_) => _sse([_frame('cancel', 'bye')]));
final events = await s.stream().listen('x').toList();
expect(s.requests[1].url.host, 'other');
expect(s.requests[1].headers['Accept'], 'text/event-stream');
final err = (events.first as RtdbDisconnected).error! as RtdbError;
expect(err.status, 401);
expect(s.slept, [const Duration(seconds: 1)]);
expect(events.last, isA<RtdbCancel>());
});
test('too many redirects is a disconnect', () async {
final s = _Server();
for (var i = 0; i < 5; i++) {
s.script.add(
(_) => http.StreamedResponse(
const Stream.empty(),
307,
headers: {'location': '/again'},
),
);
}
s.script.add((_) => _sse([_frame('cancel', 'bye')]));
final events = await s.stream().listen('x').toList();
expect((events.first as RtdbDisconnected).error, isA<RtdbError>());
});
test('clean end, socket error and bad frame all back off', () async {
final broken = StreamController<List<int>>();
final s = _Server()
..script.add((_) => _sse([]))
..script.add((_) {
broken.addError(http.ClientException('reset'));
return http.StreamedResponse(broken.stream, 200);
})
..script.add((_) => _sse([_frame('put', 'not json')], close: false))
..script.add((_) => _sse([_frame('cancel', 'bye')]));
final events = await s.stream().listen('x').toList();
final drops = events.whereType<RtdbDisconnected>().toList();
expect(drops[0].error, isNull);
expect(drops[1].error, isA<http.ClientException>());
expect(drops[2].error, isA<FormatException>());
expect(s.slept, hasLength(3));
await broken.close();
});
test('cancelling the subscription stops reconnecting', () async {
final s = _Server()
..script.add(
(_) => _sse([_frame('put', '{"path":"/","data":1}')], close: false),
);
final got = Completer<void>();
final sub = s.stream().listen('x').listen((e) {
if (e is RtdbPut) got.complete();
});
await got.future;
await sub.cancel();
await Future<void>.delayed(Duration.zero);
expect(s.requests, hasLength(1));
});
test('a listen cancelled while connecting aborts and lets go', () async {
// RTDB is HTTP/1.1: a browser has 6 connections to it. A leaked listen
// starved the next session's meta/msgs (empty chat after Next card).
final server = _Server();
final gate = Completer<void>();
var released = false;
final body = StreamController<List<int>>(onCancel: () => released = true);
server.script.add((_) => http.StreamedResponse(body.stream, 200));
final client = MockClient.streaming((req, _) async {
server.requests.add(req);
await gate.future;
return server.script.removeAt(0)(req);
});
final stream = RtdbStream(
RtdbClient(
layout: tutorLayout,
databaseUrl: 'https://db',
idToken: () async => 'tok',
httpClient: client,
),
sleep: (d) async {},
);
final sub = stream.listen('tutor/v1-e2e/live').listen((_) {});
await Future<void>.delayed(Duration.zero);
final req = server.requests.single as http.Abortable;
var aborted = false;
unawaited(req.abortTrigger!.then((_) => aborted = true));
await sub.cancel();
await Future<void>.delayed(Duration.zero);
expect(aborted, isTrue);
gate.complete();
await Future<void>.delayed(Duration.zero);
await Future<void>.delayed(Duration.zero);
expect(released, isTrue);
});
}

View File

@ -0,0 +1,28 @@
import 'dart:convert';
import 'dart:io';
import 'package:crdt_sync/crdt_sync.dart' show Argon2Params, E2eCipher;
import 'package:rtdb_relay/src/rtdb_client.dart';
import 'package:rtdb_relay/src/sealer.dart';
import 'fake_rtdb.dart';
import 'tutor_layout.dart';
const fastArgon = Argon2Params(memoryKiB: 8, iterations: 1, parallelism: 1);
const testRid = '01J0000000000000000000000R';
final Map<String, dynamic> e2eVectors = jsonDecode(
File('test/data/e2e_vectors.json').readAsStringSync(),
) as Map<String, dynamic>;
RelaySealer vectorSealer() => RelaySealer(
E2eCipher(hexBytes(e2eVectors['key_hex'] as String)),
layout: tutorLayout,
);
List<int> hexBytes(String s) => [
for (var i = 0; i < s.length; i += 2)
int.parse(s.substring(i, i + 2), radix: 16),
];
RtdbClient sealedClient(FakeRtdb db) => db.client()..sealer = vectorSealer();

View File

@ -0,0 +1,93 @@
/// An in-memory RTDB REST server behind a MockClient: GET (shallow,
/// `orderBy="$key"` + `startAt`), PUT (resolving `.sv` timestamps), PATCH,
/// DELETE. Enough for the logic tests; streaming is faked separately.
library;
import 'dart:convert';
import 'package:http/http.dart' as http;
import 'package:http/testing.dart';
import 'package:rtdb_relay/src/json_tree.dart';
import 'package:rtdb_relay/src/rtdb_client.dart';
import 'tutor_layout.dart';
/// The fake database.
class FakeRtdb {
/// The whole tree.
Object? root;
/// Server time used for `{".sv":"timestamp"}`.
int serverTime = 1791731346000;
/// Requests seen, as `METHOD path`.
final List<String> log = [];
/// When set, every request throws a network error.
bool offline = false;
/// Requests whose path starts with this throw a network error.
String? failPrefix;
/// A client wired to this fake.
///
/// The namespace is pinned to production (''): a phone slot build of the
/// screenshot fixture sets SYNC_NAMESPACE=sandbox/slotN, which would
/// otherwise move every read under a prefix this in-memory tree lacks
/// (Home and Progress came up empty on the Pixel).
RtdbClient client() => RtdbClient(
layout: tutorLayout,
databaseUrl: 'https://fake',
idToken: () async => 'tok',
httpClient: MockClient(_handle),
namespace: '',
);
Object? _resolve(Object? v) {
if (v is Map<String, dynamic>) {
if (v.length == 1 && v['.sv'] == 'timestamp') return serverTime;
return {for (final e in v.entries) e.key: _resolve(e.value)};
}
return v;
}
Future<http.Response> _handle(http.Request req) async {
if (offline) throw http.ClientException('offline');
final path = req.url.path.replaceFirst(RegExp(r'\.json$'), '');
if (failPrefix != null && path.startsWith(failPrefix!)) {
throw http.ClientException('unreachable');
}
log.add('${req.method} $path');
final q = req.url.queryParameters;
switch (req.method) {
case 'GET':
var value = getAt(root, path);
if (q['shallow'] == 'true' && value is Map<String, dynamic>) {
value = {for (final k in value.keys) k: true};
}
final start = q['startAt'];
if (start != null && value is Map<String, dynamic>) {
final from = jsonDecode(start) as String;
value = {
for (final e in value.entries)
if (e.key.compareTo(from) >= 0) e.key: e.value,
};
if (value.isEmpty) value = null;
}
return http.Response(jsonEncode(value), 200);
case 'PUT':
final value = _resolve(jsonDecode(req.body));
root = setAt(root, path, value);
return http.Response(jsonEncode(value), 200);
case 'PATCH':
final patch = jsonDecode(req.body) as Map<String, dynamic>;
for (final e in patch.entries) {
root = setAt(root, '$path/${e.key}', _resolve(e.value));
}
return http.Response(req.body, 200);
default: // DELETE
root = setAt(root, path, null);
return http.Response('null', 200);
}
}
}

View File

@ -0,0 +1,84 @@
/// An [RtdbStream] whose events the test pushes by path.
///
/// It also counts the listens open at once, as a browser counts the
/// connections they hold: RTDB speaks HTTP/1.1 and Chrome gives a host 6, so
/// the app must keep its streams well under that (`stream_budget_test`).
library;
import 'dart:async';
import 'dart:math';
import 'package:rtdb_relay/src/rtdb_client.dart';
import 'package:rtdb_relay/src/rtdb_event.dart';
import 'package:rtdb_relay/src/rtdb_stream.dart';
/// The fake transport.
class FakeStream implements RtdbStream {
/// Listens by path (the latest one per path), open or not.
final Map<String, StreamController<RtdbEvent>> listens = {};
/// The query of the latest listen per path.
final Map<String, Map<String, String>> queries = {};
final Set<StreamController<RtdbEvent>> _open = {};
final Map<StreamController<RtdbEvent>, String> _paths = {};
/// The most listens ever open at once, and which they were.
int peak = 0;
/// The paths open when [peak] was reached.
List<String> peakPaths = const [];
/// The paths of the listens open now.
List<String> get openPaths => [for (final c in _open) _paths[c]!];
@override
RtdbClient get client => throw UnimplementedError();
@override
Stream<RtdbEvent> listen(
String path, {
Map<String, String> query = const {},
}) {
queries[path] = query;
late final StreamController<RtdbEvent> c;
c = StreamController<RtdbEvent>(
onListen: () {
_open.add(c);
if (_open.length > peak) {
peak = _open.length;
peakPaths = openPaths;
}
},
onCancel: () => _open.remove(c),
);
_paths[c] = path;
return (listens[path] = c).stream;
}
/// Delivers [event] for [path] as RTDB does: to the open listen on that
/// path, else to the nearest open listen above it with the event's path
/// prefixed by the rest. False when nothing listens there.
bool emit(String path, RtdbEvent event) {
for (var at = path; at.isNotEmpty; at = _parent(at)) {
final c = listens[at];
if (c == null || !_open.contains(c)) continue;
final rest = path.substring(at.length);
c.add(rest.isEmpty ? event : _under(rest, event));
return true;
}
return false;
}
static String _parent(String path) =>
path.substring(0, max(0, path.lastIndexOf('/')));
static RtdbEvent _under(String rest, RtdbEvent event) {
String join(String p) => p == '/' ? rest : '$rest$p';
return switch (event) {
RtdbPut(:final path, :final data) => RtdbPut(join(path), data),
RtdbPatch(:final path, :final data) => RtdbPatch(join(path), data),
_ => event,
};
}
}

View File

@ -0,0 +1,244 @@
// FROZEN copy of the tutor app's lib/sync/e2e_seal.dart at tutor d72bba7, the
// code the phone APK ran before the extraction. Only the differential test
// reads it; never edit it (doc comments stripped for the line cap).
// ignore_for_file: type=lint
/// End-to-end encryption of the tutor's RTDB tree (DOCS-contract §12).
library;
import 'dart:convert';
import 'package:crdt_sync/crdt_sync.dart' show E2eCipher, E2eLayout;
const String kOldRoot = 'tutor/v1';
final E2eLayout kE2eLayout = E2eLayout.of(kOldRoot);
const String kSealedKey = '_e2e';
const List<String> _clear = [
'meta',
'rev',
'migration',
'requests/*/claim',
'sessions/*/progress/rid',
];
const Map<String, Set<String>> _units = {
'live': {},
'prefs/*': {},
'stats/*': {},
'presence/workers/*': {'beat'},
'presence/clients/*': {'seen'},
'uploads/*/*': {},
'requests/*/req': {'created'},
'requests/*/result': {'at'},
'sessions/*/meta/*': {},
'sessions/*/msgs/*': {},
'sessions/*/receipts/*': {},
'sessions/*/user/*': {},
'sessions/*/progress/steps/*': {},
'session_index/*': {},
'subjects/*/meta': {},
'subjects/*/plan': {},
'subjects/*/cards': {},
'subjects/*/concepts': {},
'log/*/*': {},
'feedback/*': {},
};
class E2eLayoutError implements Exception {
const new(this.message);
final String message;
@override
String toString() => 'E2eLayoutError: $message';
}
enum E2eRuleKind { clear, unit, below, struct, unknown }
class E2eRule {
const new(this.kind, [this.depth = 0, this.keep = const {}]);
final E2eRuleKind kind;
final int depth;
final Set<String> keep;
}
Object? _pruned(Object? value) {
if (value is! Map) return value;
final out = <String, Object?>{};
for (final e in value.entries) {
final v = _pruned(e.value);
if (v != null) out[e.key as String] = v;
}
return out.isEmpty ? null : out;
}
List<String> e2eParts(String path) =>
path.split('/').where((s) => s.isNotEmpty).toList();
bool _matches(List<String> pattern, List<String> parts) {
if (pattern.length != parts.length) return false;
for (var i = 0; i < parts.length; i++) {
if (pattern[i] != '*' && pattern[i] != parts[i]) return false;
}
return true;
}
E2eRule classifyE2e(List<String> parts) {
for (final pattern in _clear) {
final pat = pattern.split('/');
if (pat.length <= parts.length &&
_matches(pat, parts.sublist(0, pat.length))) {
return const E2eRule(E2eRuleKind.clear);
}
}
for (final entry in _units.entries) {
final pat = entry.key.split('/');
if (_matches(pat, parts)) {
return E2eRule(E2eRuleKind.unit, pat.length, entry.value);
}
if (pat.length < parts.length &&
_matches(pat, parts.sublist(0, pat.length))) {
return E2eRule(E2eRuleKind.below, pat.length, entry.value);
}
}
for (final pattern in [..._clear, ..._units.keys]) {
final pat = pattern.split('/');
if (parts.length < pat.length &&
_matches(pat.sublist(0, parts.length), parts)) {
return const E2eRule(E2eRuleKind.struct);
}
}
return const E2eRule(E2eRuleKind.unknown);
}
String? e2eUnitPath(String rel) {
final parts = e2eParts(rel);
final rule = classifyE2e(parts);
return rule.kind == E2eRuleKind.below
? parts.sublist(0, rule.depth).join('/')
: null;
}
class TutorSealer {
new(this.cipher, {String? root}) : root = root ?? kE2eLayout.prefix;
final E2eCipher cipher;
final String root;
String _aad(List<String> parts) => [root, ...parts].join('/');
Future<Object?> seal(String rel, Object? value) =>
_seal(e2eParts(rel), value);
Future<Map<String, Object?>> sealPatch(
String rel,
Map<String, Object?> body,
) async {
final base = e2eParts(rel);
final kind = classifyE2e(base).kind;
if (kind == E2eRuleKind.unit || kind == E2eRuleKind.below) {
throw E2eLayoutError('PATCH into sealed unit $rel');
}
return {
for (final e in body.entries)
e.key: await _seal([...base, ...e2eParts(e.key)], e.value),
};
}
Future<Object?> _seal(List<String> parts, Object? value) async {
final rule = classifyE2e(parts);
if (rule.kind == E2eRuleKind.clear || value == null) return value;
if (rule.kind == E2eRuleKind.unit) {
return await _sealUnit(parts, value, rule.keep);
}
if (rule.kind == E2eRuleKind.struct && value is Map) {
return {
for (final e in value.entries)
e.key as String: await _seal([
...parts,
...e2eParts(e.key as String),
], e.value),
};
}
throw E2eLayoutError(
'no e2e rule for a ${value.runtimeType} at ${parts.join('/')} '
'(${rule.kind.name})',
);
}
Future<Map<String, Object?>?> _sealUnit(
List<String> parts,
Object raw,
Set<String> keep,
) async {
// As RTDB would keep it: no null members, no empty objects.
final value = _pruned(raw);
if (value == null) return null;
var body = value;
final clear = <String, Object?>{};
if (value is Map && keep.isNotEmpty) {
body = {
for (final e in value.entries)
if (!keep.contains(e.key)) e.key as String: e.value,
};
for (final e in value.entries) {
if (keep.contains(e.key)) clear[e.key as String] = e.value;
}
}
final blob = await cipher.seal(jsonEncode(body), path: _aad(parts));
return {kSealedKey: blob, ...clear};
}
Future<Object?> open(String rel, Object? value) =>
_open(e2eParts(rel), value);
Future<Object?> _open(List<String> parts, Object? value) async {
final rule = classifyE2e(parts);
switch (rule.kind) {
case E2eRuleKind.unit:
return await _openUnit(parts, value);
case E2eRuleKind.below:
throw E2eLayoutError('read below sealed unit: ${parts.join('/')}');
case E2eRuleKind.struct when value is Map:
final out = <String, Object?>{};
for (final e in value.entries) {
final v = await _open([...parts, e.key as String], e.value);
if (v != null) out[e.key as String] = v;
}
return out;
case E2eRuleKind.struct when value is List:
return [
for (var i = 0; i < value.length; i++)
await _open([...parts, '$i'], value[i]),
];
case _:
return value;
}
}
Future<Object?> _openUnit(List<String> parts, Object? value) async {
if (value is! Map || value[kSealedKey] is! String) return value;
try {
final text = await cipher.open(
value[kSealedKey] as String,
path: _aad(parts),
);
final data = jsonDecode(text);
if (data is! Map) return data;
return <String, Object?>{
...data.cast<String, Object?>(),
for (final e in value.entries)
if (e.key != kSealedKey) e.key as String: e.value,
};
} on FormatException {
// E2eDecryptError is one: tampered, moved, or another key.
return null;
}
}
}

View File

@ -0,0 +1,37 @@
// The tutor app's layout (tutor DOCS-contract §12): the first consumer and
// the one its e2e vectors pin, so the tests run against the real tree.
import 'package:rtdb_relay/src/layout.dart';
/// The tutor's sealed tree, `tutor/v1-e2e`.
final RelayLayout tutorLayout = RelayLayout(
'tutor/v1',
clear: const [
'meta',
'rev',
'migration',
'requests/*/claim',
'sessions/*/progress/rid',
],
units: const {
'live': {},
'prefs/*': {},
'stats/*': {},
'presence/workers/*': {'beat'},
'presence/clients/*': {'seen'},
'uploads/*/*': {},
'requests/*/req': {'created'},
'requests/*/result': {'at'},
'sessions/*/meta/*': {},
'sessions/*/msgs/*': {},
'sessions/*/receipts/*': {},
'sessions/*/user/*': {},
'sessions/*/progress/steps/*': {},
'session_index/*': {},
'subjects/*/meta': {},
'subjects/*/plan': {},
'subjects/*/cards': {},
'subjects/*/concepts': {},
'log/*/*': {},
'feedback/*': {},
},
);

View File

@ -0,0 +1,98 @@
import 'dart:convert';
import 'package:crdt_sync/crdt_sync.dart' show InMemoryCredentialStore;
import 'package:flutter_test/flutter_test.dart';
import 'package:http/http.dart' as http;
import 'package:http/testing.dart';
import 'package:rtdb_relay/src/auth.dart';
import 'package:rtdb_relay/src/wrapper_credentials.dart';
String _jwt(Map<String, Object> payload) {
final body = base64Url.encode(utf8.encode(jsonEncode(payload)));
return 'h.${body.replaceAll('=', '')}.s';
}
Map<String, Object> _creds(String token) => {
'id_token': token,
'refresh_token': 'r',
'expires_at': '2099-01-01T00:00:00.000Z',
};
void main() {
final base = Uri.parse('http://127.0.0.1:8778/app/');
test('uid from the id token', () {
expect(uidOfIdToken(_jwt({'user_id': 'u'})), 'u');
expect(uidOfIdToken(_jwt({'sub': 's'})), 's');
expect(uidOfIdToken(_jwt({'sub': 1})), isNull);
expect(uidOfIdToken('a.b'), isNull);
expect(uidOfIdToken('a.!!!.c'), isNull);
expect(uidOfIdToken('h.${base64Url.encode(utf8.encode('[1]'))}.s'), isNull);
});
Future<bool> adopt(http.Response Function(http.Request) answer) async {
final store = InMemoryCredentialStore();
final ok = await adoptWrapperCredentials(
base: base,
client: MockClient((r) async {
expect(r.url.path, '/app/sync-credentials');
return answer(r);
}),
store: store,
expectedUid: 'u',
);
expect(await store.load() != null, ok);
return ok;
}
test('adopts the right account only', () async {
expect(
await adopt(
(_) => http.Response(jsonEncode(_creds(_jwt({'user_id': 'u'}))), 200),
),
isTrue,
);
expect(
await adopt(
(_) => http.Response(jsonEncode(_creds(_jwt({'user_id': 'x'}))), 200),
),
isFalse,
);
expect(await adopt((_) => http.Response('', 404)), isFalse);
expect(await adopt((_) => http.Response('[1]', 200)), isFalse);
expect(
await adopt((_) => http.Response(jsonEncode({'id_token': 'x'}), 200)),
isFalse,
);
expect(
await adopt((_) => throw http.ClientException('no wrapper')),
isFalse,
);
});
test('auth: the desktop adopts on the first session probe', () async {
final token = _jwt({'user_id': 'u'});
final store = InMemoryCredentialStore();
final client = MockClient(
(_) async => http.Response(jsonEncode(_creds(token)), 200),
);
final auth = RelayAuth(
config: const RelayFirebaseConfig(
apiKey: 'k',
databaseUrl: 'https://db',
syncUid: 'u',
serverClientId: '',
),
googleToken: ({required serverClientId}) async => null,
store: store,
httpClient: client,
adopt: () => adoptWrapperCredentials(
base: base,
client: client,
store: store,
expectedUid: 'u',
),
);
expect(await auth.hasSession(), isTrue);
});
}