@_nazmiforreal/flutter-ota 0.1.0 → 0.1.2

package/dart-src/plugins/postgres/lib/src/postgres_client.dart

@@ -0,0 +1,90 @@
+import 'package:postgres/postgres.dart';
+
+import 'postgres_config.dart';
+
+/// Minimal Postgres session contract used by the plugin.
+///
+/// Mirrors the surface the Dart port needs from `package:postgres`
+/// (`Session`/`SessionExecutor`): parameterized `execute` returning column maps,
+/// `runTx` for transactional `commitBundle`, and `close`.
+///
+/// A mock implementation backs the unit tests (see `test/mock_postgres_client.dart`).
+abstract class PostgresClientLike {
+  /// Runs [sql] with named [parameters] (e.g. `@id`) and returns rows as
+  /// column-name → value maps.
+  Future<List<Map<String, dynamic>>> execute(
+    String sql,
+    Map<String, dynamic> parameters,
+  );
+
+  /// Runs [fn] inside a transaction. The argument is a client bound to the
+  /// transaction session (only `execute` is supported on it; nested
+  /// transactions are not supported).
+  Future<T> runTx<T>(Future<T> Function(PostgresClientLike tx) fn);
+
+  /// Closes the underlying connection.
+  Future<void> close();
+}
+
+/// Real [PostgresClientLike] backed by `package:postgres`.
+///
+/// The connection is opened lazily on first use (so `createDatabasePlugin`'s
+/// synchronous `factory` can build this client without `await`).
+class PostgresClient implements PostgresClientLike {
+  PostgresClient._(this._config, this._session, this._executor);
+
+  final PostgresConfig _config;
+  Session? _session;
+  SessionExecutor? _executor;
+
+  /// Creates a client that will open a real connection on first use.
+  factory PostgresClient.connect(PostgresConfig config) =>
+      PostgresClient._(config, null, null);
+
+  Future<Session> get _activeSession async {
+    if (_session != null) return _session!;
+    final endpoint = Endpoint(
+      host: _config.host,
+      port: _config.port,
+      database: _config.database,
+      username: _config.username,
+      password: _config.password,
+    );
+    final connection = await Connection.open(
+      endpoint,
+      settings: ConnectionSettings(sslMode: _config.sslMode),
+    );
+    _session = connection;
+    _executor = connection;
+    return connection;
+  }
+
+  @override
+  Future<List<Map<String, dynamic>>> execute(
+    String sql,
+    Map<String, dynamic> parameters,
+  ) async {
+    final session = await _activeSession;
+    final result = await session.execute(sql, parameters: parameters);
+    return result.map((row) => row.toColumnMap()).toList();
+  }
+
+  @override
+  Future<T> runTx<T>(Future<T> Function(PostgresClientLike tx) fn) async {
+    final executor = _executor;
+    if (executor == null) {
+      throw UnsupportedError('Nested transactions are not supported');
+    }
+    return executor.runTx((tx) => fn(PostgresClient._(_config, tx, null)));
+  }
+
+  @override
+  Future<void> close() async {
+    final executor = _executor;
+    if (executor != null) {
+      await executor.close();
+      _session = null;
+      _executor = null;
+    }
+  }
+}

package/dart-src/plugins/postgres/lib/src/postgres_config.dart

@@ -0,0 +1,35 @@
+import 'package:postgres/postgres.dart';
+
+import 'postgres_client.dart';
+
+/// Connection configuration for the Postgres backend.
+///
+/// Faithful port of hot-updater `PostgresConfig extends PoolConfig` (the `pg`
+/// connection options). Mirrors the Supabase plugin's `clientFactory` seam:
+/// when [clientFactory] is provided, the plugin uses the injected client instead
+/// of opening a real connection — this is what makes the plugin unit-testable
+/// without a live database.
+class PostgresConfig {
+  const PostgresConfig({
+    required this.host,
+    this.port = 5432,
+    required this.database,
+    this.username,
+    this.password,
+    this.sslMode,
+    this.clientFactory,
+  });
+
+  final String host;
+  final int port;
+  final String database;
+  final String? username;
+  final String? password;
+  final SslMode? sslMode;
+
+  /// Optional factory for injecting a [PostgresClientLike] (tests / custom pools).
+  final PostgresClientFactory? clientFactory;
+}
+
+/// Builds a [PostgresClientLike] from a [PostgresConfig].
+typedef PostgresClientFactory = PostgresClientLike Function(PostgresConfig config);

package/dart-src/plugins/postgres/lib/src/postgres_database.dart

@@ -0,0 +1,302 @@
+/// Faithful port of hot-updater `plugins/postgres/src/postgres.ts`.
+library;
+
+import 'package:flutter_patcher_core/flutter_patcher_core.dart'
+    show Bundle, UpdateInfo;
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show
+        AbstractDatabasePlugin,
+        BundleChange,
+        BundleChangeOperation,
+        DatabaseBundleQueryOptions,
+        DatabaseBundleQueryOrder,
+        DatabaseBundleQueryWhere,
+        DatabasePlugin,
+        DatabasePluginHooks,
+        GetBundlesArgs,
+        Paginated,
+        calculatePagination,
+        createDatabasePlugin;
+
+import 'postgres_bundle_mapper.dart';
+import 'postgres_client.dart';
+import 'postgres_config.dart';
+import 'postgres_get_update_info.dart' as pg_ui;
+import 'postgres_types.dart';
+
+/// Postgres-backed [DatabasePlugin] factory.
+///
+/// Mirrors `postgres` from hot-updater: a `createDatabasePlugin` wrapper whose
+/// inner factory builds a Postgres client and returns an [AbstractDatabasePlugin]
+/// implementation talking to the `bundles` / `bundle_patches` tables and the
+/// update-info RPCs.
+DatabasePlugin Function() Function(
+  PostgresConfig config, [
+  DatabasePluginHooks? hooks,
+]) postgresDatabase = createDatabasePlugin<PostgresConfig>(
+  name: 'postgresDatabase',
+  factory: (config) {
+    final client = config.clientFactory != null
+        ? config.clientFactory!(config)
+        : PostgresClient.connect(config);
+
+    Future<Map<String, List<PostgresBundlePatchRow>>> fetchPatchMap(
+      List<String> bundleIds,
+    ) async {
+      final patchMap = <String, List<PostgresBundlePatchRow>>{};
+      if (bundleIds.isEmpty) return patchMap;
+
+      final rows = await client.execute(
+        'SELECT * FROM bundle_patches '
+        'WHERE bundle_id = ANY(@bundle_ids) ORDER BY order_index ASC',
+        {'bundle_ids': bundleIds},
+      );
+
+      for (final raw in rows) {
+        final row = PostgresBundlePatchRow.fromJson(raw);
+        final current = patchMap[row.bundleId] ?? [];
+        current.add(row);
+        patchMap[row.bundleId] = current;
+      }
+      return patchMap;
+    }
+
+    return _PostgresDatabasePlugin(
+      client: client,
+      fetchPatchMap: fetchPatchMap,
+    );
+  },
+);
+
+/// Build a SQL `WHERE` fragment (with `@pN` placeholders) from [where].
+(String where, Map<String, dynamic> params) _buildWhere(
+  DatabaseBundleQueryWhere? where,
+) {
+  final conditions = <String>[];
+  final params = <String, dynamic>{};
+  if (where == null) return ('', params);
+
+  var index = 0;
+  String next() => '@p${index++}';
+
+  void add(String sql, dynamic value) {
+    final p = next();
+    conditions.add(sql.replaceAll('?', p));
+    params[p] = value;
+  }
+
+  if (where.channel != null) {
+    add('channel = ?', where.channel);
+  }
+  if (where.platform != null) {
+    add('platform = ?', where.platform!.value);
+  }
+  if (where.enabled != null) {
+    add('enabled = ?', where.enabled);
+  }
+  if (where.fingerprintHash != null) {
+    if (where.fingerprintHash == null) {
+      conditions.add('fingerprint_hash IS NULL');
+    } else {
+      add('fingerprint_hash = ?', where.fingerprintHash);
+    }
+  }
+  if (where.targetAppVersion != null) {
+    if (where.targetAppVersion == null) {
+      conditions.add('target_app_version IS NULL');
+    } else {
+      add('target_app_version = ?', where.targetAppVersion);
+    }
+  }
+  if (where.targetAppVersionIn != null) {
+    add('target_app_version = ANY(?)', where.targetAppVersionIn);
+  }
+  if (where.targetAppVersionNotNull == true) {
+    conditions.add('target_app_version IS NOT NULL');
+  }
+  if (where.id != null) {
+    final id = where.id!;
+    if (id.eq != null) add('id = ?', id.eq);
+    if (id.gt != null) add('id > ?', id.gt);
+    if (id.gte != null) add('id >= ?', id.gte);
+    if (id.lt != null) add('id < ?', id.lt);
+    if (id.lte != null) add('id <= ?', id.lte);
+    if (id.ins != null) add('id = ANY(?)', id.ins);
+  }
+
+  return (
+    conditions.isEmpty ? '' : 'WHERE ${conditions.join(' AND ')}',
+    params,
+  );
+}
+
+class _PostgresDatabasePlugin implements AbstractDatabasePlugin {
+  final PostgresClientLike client;
+  final Future<Map<String, List<PostgresBundlePatchRow>>> Function(
+    List<String> bundleIds,
+  ) fetchPatchMap;
+
+  _PostgresDatabasePlugin({
+    required this.client,
+    required this.fetchPatchMap,
+  });
+
+  @override
+  bool get supportsCursorPagination => false;
+
+  @override
+  Future<UpdateInfo?> getUpdateInfo(GetBundlesArgs args) =>
+      pg_ui.getUpdateInfo(client, args);
+
+  @override
+  Future<Bundle?> getBundleById(String bundleId) async {
+    final results = await Future.wait([
+      client.execute(
+        'SELECT * FROM bundles WHERE id = @p0',
+        {'p0': bundleId},
+      ),
+      fetchPatchMap([bundleId]),
+    ]);
+
+    final data = results[0] as List<Map<String, dynamic>>;
+    if (data.isEmpty) return null;
+    final row = PostgresBundleRow.fromJson(data.first);
+    final patches = (results[1] as Map<String, List<PostgresBundlePatchRow>>)[bundleId] ?? [];
+    return mapRowToBundle(row, patches);
+  }
+
+  @override
+  Future<Paginated<List<Bundle>>> getBundles(
+    DatabaseBundleQueryOptions options,
+  ) async {
+    final where = options.where;
+    final limit = options.limit;
+    final orderBy =
+        options.orderBy ?? const DatabaseBundleQueryOrder(direction: 'desc');
+    final offset =
+        options.offset ?? (options.page != null ? (options.page! - 1) * limit : 0);
+
+    if ((where?.targetAppVersionIn != null && where!.targetAppVersionIn!.isEmpty) ||
+        (where?.id?.ins != null && where!.id!.ins!.isEmpty)) {
+      return Paginated(
+        data: const [],
+        pagination: calculatePagination(0, limit: limit, offset: offset),
+      );
+    }
+
+    final (whereSql, whereParams) = _buildWhere(where);
+
+    final countRows = await client.execute(
+      'SELECT COUNT(*) AS total FROM bundles $whereSql',
+      whereParams,
+    );
+    final total = countRows.isEmpty
+        ? 0
+        : (countRows.first['total'] as num?)?.toInt() ?? 0;
+
+    final selectParams = <String, dynamic>{...whereParams};
+    if (limit > 0) selectParams['@limit'] = limit;
+    if (offset > 0) selectParams['@offset'] = offset;
+
+    final dataRows = await client.execute(
+      'SELECT * FROM bundles $whereSql '
+      'ORDER BY id ${orderBy.direction == 'asc' ? 'asc' : 'desc'}'
+      '${limit > 0 ? ' LIMIT @limit' : ''}'
+      '${offset > 0 ? ' OFFSET @offset' : ''}',
+      selectParams,
+    );
+
+    final patchMap = await fetchPatchMap(
+      dataRows.map((row) => row['id'] as String).toList(),
+    );
+    final bundles = dataRows.map((row) {
+      final bundleRow = PostgresBundleRow.fromJson(row);
+      return mapRowToBundle(bundleRow, patchMap[bundleRow.id] ?? []);
+    }).toList();
+
+    return Paginated(
+      data: bundles,
+      pagination: calculatePagination(total, limit: limit, offset: offset),
+    );
+  }
+
+  @override
+  Future<List<String>> getChannels() async {
+    final rows = await client.execute(
+      'SELECT channel FROM bundles GROUP BY channel',
+      {},
+    );
+    return rows.map((row) => row['channel'] as String).toList();
+  }
+
+  @override
+  Future<void> commitBundle({
+    required List<BundleChange> changedSets,
+  }) async {
+    if (changedSets.isEmpty) return;
+
+    await client.runTx((tx) async {
+      for (final op in changedSets) {
+        if (op.operation == BundleChangeOperation.delete) {
+          await tx.execute(
+            'DELETE FROM bundle_patches WHERE bundle_id = @p0',
+            {'p0': op.data.id},
+          );
+          await tx.execute(
+            'DELETE FROM bundle_patches WHERE base_bundle_id = @p0',
+            {'p0': op.data.id},
+          );
+          final result = await tx.execute(
+            'DELETE FROM bundles WHERE id = @p0 RETURNING id',
+            {'p0': op.data.id},
+          );
+          if (result.isEmpty) {
+            throw StateError('Bundle with id ${op.data.id} not found');
+          }
+        } else {
+          final bundle = op.data;
+          final values = bundleToRowValues(bundle);
+          final columns = values.keys.toList();
+          final insertCols = columns.join(', ');
+          final placeholders =
+              columns.map((c) => '@${c.replaceAll('.', '_')}').join(', ');
+          final updateSets = columns
+              .where((c) => c != 'id')
+              .map((c) => '$c = EXCLUDED.$c')
+              .join(', ');
+          await tx.execute(
+            'INSERT INTO bundles ($insertCols) VALUES ($placeholders) '
+            'ON CONFLICT (id) DO UPDATE SET $updateSets',
+            {for (final c in columns) c.replaceAll('.', '_'): values[c]},
+          );
+
+          await tx.execute(
+            'DELETE FROM bundle_patches WHERE bundle_id = @p0',
+            {'p0': bundle.id},
+          );
+          final patchRows = bundleToPatchRows(bundle);
+          if (patchRows.isNotEmpty) {
+            for (final pr in patchRows) {
+              final patchCols = pr.keys.toList();
+              final patchInsert = patchCols.join(', ');
+              final patchPlaceholders =
+                  patchCols.map((c) => '@${c.replaceAll('.', '_')}').join(', ');
+              await tx.execute(
+                'INSERT INTO bundle_patches ($patchInsert) '
+                'VALUES ($patchPlaceholders) '
+                'ON CONFLICT (id) DO UPDATE SET '
+                '${patchCols.where((c) => c != 'id').map((c) => '$c = EXCLUDED.$c').join(', ')}',
+                {for (final c in patchCols) c.replaceAll('.', '_'): pr[c]},
+              );
+            }
+          }
+        }
+      }
+    });
+  }
+
+  @override
+  Future<void> onUnmount() async {
+    await client.close();
+  }
+}

package/dart-src/plugins/postgres/lib/src/postgres_get_update_info.dart

@@ -0,0 +1,120 @@
+/// Faithful port of hot-updater `plugins/postgres/src/getUpdateInfo.ts`.
+///
+/// Calls the PL/pgSQL RPCs (`get_target_app_version_list`,
+/// `get_update_info_by_app_version`, `get_update_info_by_fingerprint_hash`)
+/// defined in `plugins/postgres/sql/*.sql`. The DB must have those functions
+/// installed (see `supabase/migrations` parity work / Phase 5).
+library;
+
+import 'package:flutter_patcher_core/flutter_patcher_core.dart'
+    show
+        FingerprintGetBundlesArgs,
+        GetBundlesArgs,
+        AppVersionGetBundlesArgs,
+        UpdateInfo,
+        UpdateStatus,
+        UpdateStrategy;
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show filterCompatibleAppVersions;
+
+import 'postgres_client.dart';
+
+/// Row shape returned by the update-info RPCs.
+class _UpdateInfoRow {
+  const _UpdateInfoRow({
+    required this.id,
+    required this.shouldForceUpdate,
+    required this.message,
+    required this.status,
+    required this.storageUri,
+    required this.fileHash,
+  });
+
+  factory _UpdateInfoRow.fromJson(Map<String, dynamic> row) => _UpdateInfoRow(
+        id: row['id'] as String,
+        shouldForceUpdate: row['should_force_update'] as bool,
+        message: row['message'] as String?,
+        status: row['status'] as String,
+        storageUri: row['storage_uri'] as String?,
+        fileHash: row['file_hash'] as String?,
+      );
+
+  final String id;
+  final bool shouldForceUpdate;
+  final String? message;
+  final String status;
+  final String? storageUri;
+  final String? fileHash;
+}
+
+UpdateInfo mapUpdateInfoRow(_UpdateInfoRow row) => UpdateInfo(
+      id: row.id,
+      shouldForceUpdate: row.shouldForceUpdate,
+      message: row.message,
+      status: row.status == 'ROLLBACK' ? UpdateStatus.rollback : UpdateStatus.update,
+      storageUri: row.storageUri,
+      fileHash: row.fileHash,
+    );
+
+/// Resolve update info via the Postgres RPCs.
+Future<UpdateInfo?> getUpdateInfo(
+  PostgresClientLike client,
+  GetBundlesArgs args,
+) async {
+  if (args.updateStrategy == UpdateStrategy.appVersion) {
+    final appArgs = args as AppVersionGetBundlesArgs;
+    final targetRes = await client.execute(
+      'SELECT target_app_version '
+      'FROM get_target_app_version_list(@app_platform, @min_bundle_id)',
+      {
+        'app_platform': appArgs.platform.value,
+        'min_bundle_id': appArgs.minBundleId,
+      },
+    );
+
+    final targetAppVersionList = filterCompatibleAppVersions(
+      targetRes
+          .map((row) => row['target_app_version'] as String?)
+          .where((value) => value != null)
+          .cast<String>()
+          .toList(),
+      appArgs.appVersion,
+    );
+
+    final res = await client.execute(
+      'SELECT * FROM get_update_info_by_app_version('
+      '@app_platform, @app_version, @bundle_id, @min_bundle_id, '
+      '@target_channel, @target_app_version_list, @cohort)',
+      {
+        'app_platform': appArgs.platform.value,
+        'app_version': appArgs.appVersion,
+        'bundle_id': appArgs.bundleId,
+        'min_bundle_id': appArgs.minBundleId,
+        'target_channel': appArgs.channel,
+        'target_app_version_list': targetAppVersionList,
+        'cohort': appArgs.cohort,
+      },
+    );
+
+    if (res.isEmpty) return null;
+    return mapUpdateInfoRow(_UpdateInfoRow.fromJson(res.first));
+  }
+
+  final fpArgs = args as FingerprintGetBundlesArgs;
+  final res = await client.execute(
+    'SELECT * FROM get_update_info_by_fingerprint_hash('
+    '@app_platform, @bundle_id, @min_bundle_id, '
+    '@target_channel, @target_fingerprint_hash, @cohort)',
+    {
+      'app_platform': fpArgs.platform.value,
+      'bundle_id': fpArgs.bundleId,
+      'min_bundle_id': fpArgs.minBundleId,
+      'target_channel': fpArgs.channel,
+      'target_fingerprint_hash': fpArgs.fingerprintHash,
+      'cohort': fpArgs.cohort,
+    },
+  );
+
+  if (res.isEmpty) return null;
+  return mapUpdateInfoRow(_UpdateInfoRow.fromJson(res.first));
+}