halkyon/halkyon_learn_flutter/test/sync/support/sync_devices.dart

import 'dart:io';

import 'package:halkyon_learn_client/halkyon_learn_client.dart' as protocol;
import 'package:halkyon_learn_flutter/src/core/sync/sync_service.dart';
import 'package:halkyon_learn_flutter/src/feature/card/data/card_repository.dart';
import 'package:halkyon_learn_flutter/src/feature/card/data/sync_card_gateway.dart';
import 'package:halkyon_learn_flutter/src/feature/card/model/card.dart';
import 'package:halkyon_learn_flutter/src/feature/study/data/review_repository.dart';
import 'package:halkyon_learn_flutter/src/feature/study/data/sync_review_gateway.dart';
import 'package:halkyon_learn_flutter/src/feature/studyset/data/studyset_repository.dart';
import 'package:halkyon_learn_flutter/src/feature/studyset/data/sync_studyset_gateway.dart';
import 'package:halkyon_learn_flutter/src/feature/studyset/model/studyset.dart';
import 'package:postgres/postgres.dart' as pg;
import 'package:serverpod_auth_core_client/serverpod_auth_core_client.dart';
import 'package:serverpod_offline_sync_client/offline_sync.dart';
import 'package:yaml/yaml.dart';

// What the sync tests (ADR 0001, rule 9) share: devices of people signed in
// against the running development server, and a look at its database.

const _serverUrl = 'http://localhost:8080/';

/// A new anonymous person, as the app signs one in on first launch.
Future<AuthSuccess> signInAnonymously() async {
  final client = protocol.Client(_serverUrl);
  try {
    return await client.anonymousIdp.login();
  } finally {
    client.close();
  }
}

/// Runs [sql] on the running development server's database, as its operator
/// could.
///
/// `serverpod start` runs an embedded PostgreSQL. On Linux and macOS it
/// listens on a Unix socket in the server's `.serverpod/development/run` and
/// trusts local connections; elsewhere it listens on TCP as
/// `config/development.yaml` says, with the password from
/// `config/passwords.yaml`.
Future<pg.Result> queryServer(
  String sql,
  Map<String, Object?> parameters,
) async {
  final connection = await _openServerDatabase();
  try {
    return await connection.execute(pg.Sql.named(sql), parameters: parameters);
  } finally {
    await connection.close();
  }
}

Future<pg.Connection> _openServerDatabase() async {
  const server = '../halkyon_learn_server';
  const settings = pg.ConnectionSettings(sslMode: pg.SslMode.disable);
  final development = loadYaml(
    File('$server/config/development.yaml').readAsStringSync(),
  ) as YamlMap;
  final database = development['database'] as YamlMap;
  final name = database['name'] as String;
  final user = database['user'] as String;

  final socket = File(
    '$server/.serverpod/development/run/.s.PGSQL.5432',
  ).absolute.path;
  if (FileSystemEntity.typeSync(socket) ==
      FileSystemEntityType.unixDomainSock) {
    // A socket's path may be about 100 bytes at most, fewer than the
    // project's depth needs; a link in /tmp leads there by a short path, and
    // an open connection no longer needs it.
    final shortcut = Directory('/tmp').createTempSync('halkyon-pg-');
    try {
      final link = Link('${shortcut.path}/s')..createSync(socket);
      return await pg.Connection.open(
        pg.Endpoint(
          host: link.path,
          isUnixSocket: true,
          database: name,
          username: user,
        ),
        settings: settings,
      );
    } finally {
      shortcut.deleteSync(recursive: true);
    }
  }

  final passwords = loadYaml(
    File('$server/config/passwords.yaml').readAsStringSync(),
  ) as YamlMap;
  return await pg.Connection.open(
    pg.Endpoint(
      host: database['host'] as String,
      port: database['port'] as int,
      database: name,
      username: user,
      password: (passwords['development'] as YamlMap)['database'] as String,
    ),
    settings: settings,
  );
}

/// A device: its own client and session, its own local database, and the
/// app's repositories over it. It syncs only when told to.
final class SyncDevice(
  final protocol.Client _client,
  final OfflineSyncDatabaseSession _db,
  final SyncService _syncRequests,

  /// The app's studysets on this device's database.
  final StudysetRepository studysets,

  /// The app's cards on this device's database.
  final CardRepository cards,

  /// The app's reviews on this device's database.
  final ReviewRepository reviews,
) {
  /// Opens a device signed in as [person], whose local database in
  /// [database] claims [space] as its personal space.
  static Future<SyncDevice> open(
    AuthSuccess person,
    File database, {
    required protocol.UuidValue space,
  }) async {
    final session = ClientAuthSessionManager(storage: _MemoryAuthStorage());
    final client = protocol.Client(_serverUrl)..authSessionManager = session;
    await session.updateSignedInUser(person);
    final db = await client.createSyncSession(
      database.path,
      persistentUserId: space,
    );
    // The gateways ask for a sync after every write; these tests sync
    // explicitly instead, so the requests go nowhere.
    final syncRequests = SyncService(({required onMerge}) async {});
    return SyncDevice(
      client,
      db,
      syncRequests,
      StudysetRepository(SyncStudysetGateway(db, syncRequests)),
      CardRepository(
        SyncCardGateway(db, syncRequests, person.authUserId.uuid),
      ),
      ReviewRepository(SyncReviewGateway(db, syncRequests)),
    );
  }

  /// Sends this device's changes and receives everyone else's.
  Future<void> sync() => _client.offlineSync.syncOnce(_db);

  /// The studyset with [id] on this device, or null.
  Future<Studyset?> studyset(String id) async {
    for (final studyset in await studysets.all()) {
      if (studyset.id == id) {
        return studyset;
      }
    }
    return null;
  }

  /// The card with [id] in [studysetId] on this device, or null.
  Future<Card?> card(String studysetId, String id) async {
    for (final card in await cards.cardsOf(studysetId)) {
      if (card.id == id) {
        return card;
      }
    }
    return null;
  }

  /// Closes everything the device opened.
  Future<void> close() async {
    await studysets.dispose();
    await cards.dispose();
    await _syncRequests.dispose();
    await _db.close();
    _client.close();
  }
}

/// Keeps a device's session in memory, where the app uses secure storage.
final class _MemoryAuthStorage() implements ClientAuthSuccessStorage {
  AuthSuccess? _session;

  @override
  Future<AuthSuccess?> get() async => _session;

  @override
  Future<void> set(AuthSuccess? data) async {
    _session = data;
  }
}