@_nazmiforreal/flutter-ota 0.1.0 → 0.1.1

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));
+}

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

@@ -0,0 +1,205 @@
+import 'dart:convert';
+import 'dart:io';
+import 'dart:typed_data';
+
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart';
+
+import 'postgres_client.dart';
+import 'postgres_config.dart';
+
+/// Configuration for the Postgres bytea storage plugin.
+///
+/// Reuses the same [PostgresConfig] connection as the database plugin. Blob
+/// bytes are stored in a `flutter_patcher_storage(key text primary key, data
+/// bytea, content_type text)` table. Because Postgres cannot serve bytes over
+/// HTTP itself, [servingBaseUrl] may point at a thin proxy that reads from this
+/// table so device update-checks can download over HTTP (the CLI/console supply
+/// one; tests mount a local server).
+class PostgresStorageConfig {
+  const PostgresStorageConfig({
+    required this.db,
+    this.basePath,
+    this.servingBaseUrl,
+  });
+
+  final PostgresConfig db;
+  final String? basePath;
+  final String? servingBaseUrl;
+}
+
+/// Resolves the storage client for a config (test seam via [PostgresConfig.clientFactory]).
+PostgresClientLike resolvePostgresStorageClient(PostgresStorageConfig config) =>
+    config.db.clientFactory?.call(config.db) ?? PostgresClient.connect(config.db);
+
+String _storageUri(String key, String? servingBaseUrl) {
+  if (servingBaseUrl != null && servingBaseUrl.isNotEmpty) {
+    final base = servingBaseUrl.endsWith('/')
+        ? servingBaseUrl.substring(0, servingBaseUrl.length - 1)
+        : servingBaseUrl;
+    return '$base/$key';
+  }
+  return 'postgres://$key';
+}
+
+String _contentType(String key) {
+  if (key.endsWith('.json')) return 'application/json';
+  if (key.endsWith('.zip')) return 'application/zip';
+  return 'application/octet-stream';
+}
+
+String _strip(String storageUri, String? servingBaseUrl) {
+  if (storageUri.startsWith('postgres://')) {
+    return storageUri.substring('postgres://'.length);
+  }
+  if (servingBaseUrl != null && storageUri.startsWith(servingBaseUrl)) {
+    final base =
+        servingBaseUrl.endsWith('/') ? servingBaseUrl : '$servingBaseUrl/';
+    return storageUri.startsWith(base)
+        ? storageUri.substring(base.length)
+        : storageUri;
+  }
+  return storageUri;
+}
+
+Uint8List _toBytes(Object? data) {
+  if (data is Uint8List) return data;
+  if (data is List) return Uint8List.fromList(data.cast<int>());
+  return Uint8List(0);
+}
+
+NodeStorageProfile createPostgresNodeProfile(
+  PostgresClientLike client,
+  String? basePath,
+  String? servingBaseUrl,
+) =>
+    _PostgresNodeProfile(client, basePath, servingBaseUrl);
+
+class _PostgresNodeProfile implements NodeStorageProfile {
+  _PostgresNodeProfile(this._client, this._basePath, this._servingBaseUrl);
+
+  final PostgresClientLike _client;
+  final String? _basePath;
+  final String? _servingBaseUrl;
+
+  String _withBase(String key) =>
+      [_basePath, key].where((s) => s != null && s.isNotEmpty).join('/');
+
+  @override
+  Future<Map<String, String>> upload(String key, String filePath) async {
+    final fullKey = _withBase(key);
+    final bytes = await File(filePath).readAsBytes();
+    await _client.execute(
+      'INSERT INTO flutter_patcher_storage (key, data, content_type) '
+      'VALUES (@key, @data, @ct) '
+      'ON CONFLICT (key) DO UPDATE SET data = EXCLUDED.data, content_type = EXCLUDED.content_type',
+      {
+        '@key': fullKey,
+        '@data': bytes,
+        '@ct': _contentType(fullKey),
+      },
+    );
+    return {'storageUri': _storageUri(fullKey, _servingBaseUrl)};
+  }
+
+  @override
+  Future<bool> exists(String storageUri) async {
+    final key = _strip(storageUri, _servingBaseUrl);
+    final rows = await _client.execute(
+      'SELECT 1 FROM flutter_patcher_storage WHERE key = @key',
+      {'@key': key},
+    );
+    return rows.isNotEmpty;
+  }
+
+  @override
+  Future<void> delete(String storageUri) async {
+    await _client.execute(
+      'DELETE FROM flutter_patcher_storage WHERE key = @key',
+      {'@key': _strip(storageUri, _servingBaseUrl)},
+    );
+  }
+
+  @override
+  Future<void> downloadFile(String storageUri, String filePath) async {
+    final key = _strip(storageUri, _servingBaseUrl);
+    final rows = await _client.execute(
+      'SELECT data FROM flutter_patcher_storage WHERE key = @key',
+      {'@key': key},
+    );
+    if (rows.isEmpty) {
+      throw StateError('Object not found: $key');
+    }
+    await File(filePath).writeAsBytes(_toBytes(rows.first['data']));
+  }
+
+  @override
+  Future<List<StorageObject>> listObjects([String? prefix]) async {
+    final fullPrefix = prefix == null ? null : _withBase(prefix);
+    final rows = await _client.execute(
+      'SELECT key, octet_length(data) AS size FROM flutter_patcher_storage '
+      'WHERE key LIKE @prefix',
+      {'@prefix': '${fullPrefix ?? ''}%'},
+    );
+    return rows.map((r) {
+      final key = r['key'] as String;
+      return StorageObject(
+        key: key,
+        storageUri: _storageUri(key, _servingBaseUrl),
+        size: (r['size'] as int?) ?? 0,
+      );
+    }).toList();
+  }
+
+  @override
+  Future<void> deleteObjects(List<String> keys) async {
+    for (final k in keys) {
+      await _client.execute(
+        'DELETE FROM flutter_patcher_storage WHERE key = @key',
+        {'@key': _strip(k, _servingBaseUrl)},
+      );
+    }
+  }
+}
+
+RuntimeStorageProfile createPostgresRuntimeProfile(
+  PostgresClientLike client,
+  String? servingBaseUrl,
+) =>
+    _PostgresRuntimeProfile(client, servingBaseUrl);
+
+class _PostgresRuntimeProfile implements RuntimeStorageProfile {
+  _PostgresRuntimeProfile(this._client, this._servingBaseUrl);
+
+  final PostgresClientLike _client;
+  final String? _servingBaseUrl;
+
+  @override
+  Future<Map<String, String>> getDownloadUrl(String storageUri) async {
+    return {'fileUrl': _storageUri(_strip(storageUri, _servingBaseUrl), _servingBaseUrl)};
+  }
+
+  @override
+  Future<String?> readText(String storageUri) async {
+    final key = _strip(storageUri, _servingBaseUrl);
+    final rows = await _client.execute(
+      'SELECT data FROM flutter_patcher_storage WHERE key = @key',
+      {'@key': key},
+    );
+    if (rows.isEmpty) return null;
+    return utf8.decode(_toBytes(rows.first['data']));
+  }
+}
+
+/// Postgres bytea storage plugin (name `postgresStorage`, protocol `postgres`).
+StoragePlugin Function(PostgresStorageConfig) postgresStorage =
+    createUniversalStoragePlugin<PostgresStorageConfig>(
+      name: 'postgresStorage',
+      supportedProtocol: 'postgres',
+      factory: (cfg) {
+        final client = resolvePostgresStorageClient(cfg);
+        return (
+          node: createPostgresNodeProfile(client, cfg.basePath, cfg.servingBaseUrl),
+          runtime: createPostgresRuntimeProfile(client, cfg.servingBaseUrl),
+        );
+      },
+    );