@_nazmiforreal/flutter-ota 0.1.0 → 0.1.2

package/dart-src/plugins/cloudflare/lib/src/d1_database_plugin.dart

@@ -0,0 +1,314 @@
+import 'dart:convert' show jsonEncode;
+
+import 'package:flutter_patcher_core/flutter_patcher_core.dart'
+    show
+        AppVersionGetBundlesArgs,
+        Bundle,
+        FingerprintGetBundlesArgs,
+        GetBundlesArgs,
+        UpdateInfo,
+        UpdateStrategy;
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show
+        AbstractDatabasePlugin,
+        BundleChange,
+        BundleChangeOperation,
+        DatabaseBundleIdFilter,
+        DatabaseBundleQueryOptions,
+        DatabaseBundleQueryOrder,
+        DatabaseBundleQueryWhere,
+        Paginated,
+        calculatePagination,
+        filterCompatibleAppVersions,
+        resolveUpdateInfoFromBundles,
+        ResolveUpdateInfoFromBundlesOptions;
+
+import 'd1_bundle_mapper.dart'
+    show
+        bundleToPatchRows,
+        defaultRolloutCohortCount,
+        transformRowToBundle;
+import 'd1_build_where.dart' show buildWhereClause;
+import 'd1_client.dart' show D1ClientLike;
+
+/// Shared D1 database plugin logic used by both [d1Database] (REST API client)
+/// and [cloudflareWorkerDatabase] (in-process D1 binding).
+///
+/// Issues raw SQLite statements and resolves update information in-process via
+/// [resolveUpdateInfoFromBundles] (no SQL stored procedures, unlike the
+/// Supabase/Postgres backends).
+class D1DatabasePlugin implements AbstractDatabasePlugin {
+  D1DatabasePlugin(this._client);
+
+  final D1ClientLike _client;
+
+  Future<Map<String, List<Map<String, dynamic>>>> _getPatchMap(
+    List<String> bundleIds,
+  ) async {
+    final patchMap = <String, List<Map<String, dynamic>>>{};
+    if (bundleIds.isEmpty) return patchMap;
+
+    final rows = await _client.query(
+      'SELECT * FROM bundle_patches '
+      'WHERE bundle_id IN (SELECT value FROM json_each(?)) '
+      'ORDER BY order_index ASC, base_bundle_id ASC',
+      [jsonEncode(bundleIds)],
+    );
+
+    for (final row in rows) {
+      (patchMap[row['bundle_id'] as String] ??= []).add(row);
+    }
+    return patchMap;
+  }
+
+  Future<int> _getTotalCount(DatabaseBundleQueryWhere conditions) async {
+    final where = buildWhereClause(conditions);
+    final rows = await _client.query(
+      'SELECT COUNT(*) as total FROM bundles${where.sql}',
+      where.params,
+    );
+    return (rows.firstOrNull?['total'] as num?)?.toInt() ?? 0;
+  }
+
+  Future<List<Bundle>> _getPaginatedBundles(
+    DatabaseBundleQueryWhere conditions,
+    int limit,
+    int offset,
+    DatabaseBundleQueryOrder? orderBy,
+  ) async {
+    final where = buildWhereClause(conditions);
+    final orderBySql =
+        orderBy?.direction == 'asc' ? 'ORDER BY id ASC' : 'ORDER BY id DESC';
+
+    final rows = await _client.query(
+      'SELECT * FROM bundles ${where.sql} $orderBySql LIMIT ? OFFSET ?',
+      [...where.params, limit, offset],
+    );
+
+    final patchMap = await _getPatchMap(
+      rows.map((row) => row['id'] as String).toList(),
+    );
+    return rows
+        .map((row) => transformRowToBundle(row, patchMap[row['id']] ?? const []))
+        .toList();
+  }
+
+  Future<List<Bundle>> _queryBundlesForUpdateInfo(
+    DatabaseBundleQueryWhere conditions,
+  ) async {
+    final where = buildWhereClause(conditions);
+    final rows = await _client.query(
+      'SELECT * FROM bundles${where.sql}',
+      where.params,
+    );
+    final patchMap = await _getPatchMap(
+      rows.map((row) => row['id'] as String).toList(),
+    );
+    return rows
+        .map((row) => transformRowToBundle(row, patchMap[row['id']] ?? const []))
+        .toList();
+  }
+
+  Future<List<String>> _getTargetAppVersionsForUpdateInfo({
+    required String channel,
+    required String platform,
+    required String minBundleId,
+  }) async {
+    final rows = await _client.query(
+      'SELECT target_app_version FROM bundles '
+      'WHERE channel = ? AND platform = ? AND enabled = 1 '
+      'AND id >= ? AND target_app_version IS NOT NULL '
+      'GROUP BY target_app_version',
+      [channel, platform, minBundleId],
+    );
+    return rows
+        .map((row) => row['target_app_version'] as String)
+        .toList();
+  }
+
+  @override
+  Future<UpdateInfo?> getUpdateInfo(GetBundlesArgs args) async {
+    final channel = args.channel;
+    final minBundleId = args.minBundleId;
+    final platform = args.platform.value;
+
+    if (args.updateStrategy == UpdateStrategy.appVersion) {
+      final appVersion = (args as AppVersionGetBundlesArgs).appVersion;
+      final targetAppVersions = await _getTargetAppVersionsForUpdateInfo(
+        channel: channel,
+        platform: platform,
+        minBundleId: minBundleId,
+      );
+      final compatibleAppVersions = filterCompatibleAppVersions(
+        targetAppVersions,
+        appVersion,
+      );
+      final bundles = compatibleAppVersions.isNotEmpty
+          ? await _queryBundlesForUpdateInfo(
+              DatabaseBundleQueryWhere(
+                enabled: true,
+                platform: args.platform,
+                channel: channel,
+                id: DatabaseBundleIdFilter(gte: minBundleId),
+                targetAppVersionIn: compatibleAppVersions,
+              ),
+            )
+          : const <Bundle>[];
+
+      return resolveUpdateInfoFromBundles(
+        ResolveUpdateInfoFromBundlesOptions(args: args, bundles: bundles),
+      );
+    }
+
+    final fingerprintHash = args is FingerprintGetBundlesArgs
+        ? args.fingerprintHash
+        : null;
+
+    final bundles = await _queryBundlesForUpdateInfo(
+      DatabaseBundleQueryWhere(
+        enabled: true,
+        platform: args.platform,
+        channel: channel,
+        id: DatabaseBundleIdFilter(gte: minBundleId),
+        fingerprintHash: fingerprintHash,
+      ),
+    );
+
+    return resolveUpdateInfoFromBundles(
+      ResolveUpdateInfoFromBundlesOptions(args: args, bundles: bundles),
+    );
+  }
+
+  @override
+  Future<Bundle?> getBundleById(String bundleId) async {
+    final rows = await _client.query(
+      'SELECT * FROM bundles WHERE id = ? LIMIT 1',
+      [bundleId],
+    );
+    if (rows.isEmpty) return null;
+
+    final patchMap = await _getPatchMap([bundleId]);
+    return transformRowToBundle(rows.first, patchMap[bundleId] ?? const []);
+  }
+
+  @override
+  Future<Paginated<List<Bundle>>> getBundles(
+    DatabaseBundleQueryOptions options,
+  ) async {
+    final where = options.where ?? const DatabaseBundleQueryWhere();
+    final limit = options.limit;
+    final offset = options.offset ??
+        (options.page != null ? (options.page! - 1) * limit : 0);
+
+    final totalCount = await _getTotalCount(where);
+    final bundles = await _getPaginatedBundles(
+      where,
+      limit,
+      offset,
+      options.orderBy,
+    );
+
+    final pagination = calculatePagination(
+      totalCount,
+      limit: limit,
+      offset: offset,
+    );
+
+    return Paginated<List<Bundle>>(data: bundles, pagination: pagination);
+  }
+
+  @override
+  Future<List<String>> getChannels() async {
+    final rows = await _client.query(
+      'SELECT channel FROM bundles GROUP BY channel',
+    );
+    return rows.map((row) => row['channel'] as String).toList();
+  }
+
+  @override
+  bool get supportsCursorPagination => false;
+
+  @override
+  Future<void> onUnmount() async {}
+
+  @override
+  Future<void> commitBundle({
+    required List<BundleChange> changedSets,
+  }) async {
+    if (changedSets.isEmpty) return;
+
+    for (final op in changedSets) {
+      if (op.operation == BundleChangeOperation.delete) {
+        await _client.query(
+          'DELETE FROM bundle_patches WHERE bundle_id = ?',
+          [op.data.id],
+        );
+        await _client.query(
+          'DELETE FROM bundle_patches WHERE base_bundle_id = ?',
+          [op.data.id],
+        );
+        await _client.query(
+          'DELETE FROM bundles WHERE id = ?',
+          [op.data.id],
+        );
+      } else {
+        final bundle = op.data;
+        await _client.query(
+          'INSERT OR REPLACE INTO bundles ('
+          'id, channel, enabled, should_force_update, file_hash, '
+          'git_commit_hash, message, platform, target_app_version, '
+          'storage_uri, fingerprint_hash, metadata, manifest_storage_uri, '
+          'manifest_file_hash, asset_base_storage_uri, rollout_cohort_count, '
+          'target_cohorts) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
+          [
+            bundle.id,
+            bundle.channel,
+            bundle.enabled ? 1 : 0,
+            bundle.shouldForceUpdate ? 1 : 0,
+            bundle.fileHash,
+            bundle.gitCommitHash,
+            bundle.message,
+            bundle.platform.value,
+            bundle.targetAppVersion,
+            bundle.storageUri,
+            bundle.fingerprintHash,
+            jsonEncode(
+              bundle.metadata?.toJson() ?? <String, dynamic>{},
+            ),
+            bundle.manifestStorageUri,
+            bundle.manifestFileHash,
+            bundle.assetBaseStorageUri,
+            bundle.rolloutCohortCount ?? defaultRolloutCohortCount,
+            bundle.targetCohorts != null
+                ? jsonEncode(bundle.targetCohorts)
+                : null,
+          ],
+        );
+
+        await _client.query(
+          'DELETE FROM bundle_patches WHERE bundle_id = ?',
+          [bundle.id],
+        );
+
+        final patchRows = bundleToPatchRows(bundle);
+        for (final patchRow in patchRows) {
+          await _client.query(
+            'INSERT OR REPLACE INTO bundle_patches ('
+            'id, bundle_id, base_bundle_id, base_file_hash, '
+            'patch_file_hash, patch_storage_uri, order_index) '
+            'VALUES (?, ?, ?, ?, ?, ?, ?)',
+            [
+              patchRow['id'],
+              patchRow['bundle_id'],
+              patchRow['base_bundle_id'],
+              patchRow['base_file_hash'],
+              patchRow['patch_file_hash'],
+              patchRow['patch_storage_uri'],
+              patchRow['order_index'],
+            ],
+          );
+        }
+      }
+    }
+  }
+}

package/dart-src/plugins/cloudflare/lib/src/r2_config.dart

@@ -0,0 +1,50 @@
+import 'r2_s3_client.dart' show R2S3Client, R2S3ClientLike;
+
+/// Configuration for the Cloudflare R2 S3-compatible storage plugin.
+///
+/// Mirrors hot-updater's `R2S3StorageConfig` (a thin wrapper over the AWS S3
+/// client config). Credentials are passed directly (access/secret keys) and
+/// the client signs requests with AWS Signature V4 against the R2 endpoint.
+class R2S3StorageConfig {
+  const R2S3StorageConfig({
+    required this.accountId,
+    required this.bucketName,
+    required this.accessKeyId,
+    required this.secretAccessKey,
+    this.basePath,
+    this.region = 'auto',
+    this.endpoint,
+    this.clientFactory,
+  });
+
+  /// Cloudflare account ID (used to build the R2 endpoint host).
+  final String accountId;
+
+  /// Target R2 bucket name.
+  final String bucketName;
+
+  /// S3 access key ID.
+  final String accessKeyId;
+
+  /// S3 secret access key.
+  final String secretAccessKey;
+
+  /// Optional base path prepended to all object keys.
+  final String? basePath;
+
+  /// R2 region (defaults to "auto").
+  final String region;
+
+  /// Override endpoint (defaults to `https://<accountId>.r2.cloudflarestorage.com`).
+  final String? endpoint;
+
+  /// Optional factory used to inject an [R2S3ClientLike] in tests.
+  final R2S3ClientFactory? clientFactory;
+}
+
+/// Builds an [R2S3ClientLike] for the given [R2S3StorageConfig].
+typedef R2S3ClientFactory = R2S3ClientLike Function(R2S3StorageConfig config);
+
+/// Resolves the client for a config, using the injected factory when present.
+R2S3ClientLike resolveR2Client(R2S3StorageConfig config) =>
+    config.clientFactory?.call(config) ?? R2S3Client(config);

package/dart-src/plugins/cloudflare/lib/src/r2_s3_client.dart

@@ -0,0 +1,287 @@
+import 'dart:convert' show utf8;
+import 'dart:io' show File;
+import 'dart:typed_data' show Uint8List;
+
+import 'package:crypto/crypto.dart' show Hmac, sha256;
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show StorageObject;
+import 'package:http/http.dart' show Client, Request, Response;
+
+import 'r2_config.dart' show R2S3StorageConfig;
+
+/// A thin S3-compatible client for Cloudflare R2.
+///
+/// Mirrors the subset of `@aws-sdk/client-s3` used by hot-updater's
+/// `r2S3Storage.ts`: delete / put / head / get objects, listing, and
+/// presigned GET URLs. Requests are signed with AWS Signature V4.
+abstract class R2S3ClientLike {
+  const R2S3ClientLike();
+
+  Future<void> deleteObject(String key);
+
+  Future<void> putObject(String key, List<int> body, String contentType);
+
+  Future<bool> headObject(String key);
+
+  Future<List<int>> getObjectAsBytes(String key);
+
+  Future<String> getObjectAsString(String key);
+
+  Future<String> getSignedUrl(String key, {int expiresIn = 3600});
+
+  Future<List<StorageObject>> listObjects([String? prefix]);
+
+  Future<void> deleteObjects(List<String> keys);
+}
+
+/// Real R2 S3 client backed by `package:http` + AWS SigV4 signing.
+class R2S3Client implements R2S3ClientLike {
+  R2S3Client(this.config, {Client? http}) : _http = http ?? Client();
+
+  final R2S3StorageConfig config;
+  final Client _http;
+
+  static const String _service = 'r2';
+
+  Uri _objectUri(String key) {
+    final host = config.endpoint ??
+        'https://${config.accountId}.r2.cloudflarestorage.com';
+    return Uri.parse('$host/${config.bucketName}/$key');
+  }
+
+  @override
+  Future<void> deleteObject(String key) async {
+    final response = await _send('DELETE', _objectUri(key), body: null);
+    _assertStatus(response, [200, 204], 'deleteObject');
+  }
+
+  @override
+  Future<void> putObject(
+    String key,
+    List<int> body,
+    String contentType,
+  ) async {
+    final uri = _objectUri(key);
+    final response = await _send(
+      'PUT',
+      uri,
+      body: body,
+      extraHeaders: {
+        'Content-Type': contentType,
+        'Cache-Control': 'max-age=31536000',
+      },
+    );
+    _assertStatus(response, [200], 'putObject');
+  }
+
+  @override
+  Future<bool> headObject(String key) async {
+    final uri = _objectUri(key);
+    final request = Request('HEAD', uri)..headers.addAll(_authHeaders('HEAD', uri, null));
+    final response = await _http.send(request);
+    if (response.statusCode == 404) return false;
+    if (response.statusCode < 200 || response.statusCode >= 300) {
+      throw Exception('R2 HeadObject failed (${response.statusCode})');
+    }
+    return true;
+  }
+
+  @override
+  Future<List<int>> getObjectAsBytes(String key) async {
+    final response = await _send('GET', _objectUri(key), body: null);
+    _assertStatus(response, [200], 'getObjectAsBytes');
+    return response.bodyBytes;
+  }
+
+  @override
+  Future<String> getObjectAsString(String key) async {
+    final bytes = await getObjectAsBytes(key);
+    return utf8.decode(bytes);
+  }
+
+  @override
+  Future<String> getSignedUrl(String key, {int expiresIn = 3600}) async {
+    final uri = _objectUri(key);
+    final now = DateTime.now().toUtc();
+    final amzDate = _amzDate(now);
+    final dateStamp = amzDate.substring(0, 8);
+    final scope = '$dateStamp/${config.region}/$_service/aws4_request';
+
+    final params = {
+      'X-Amz-Algorithm': 'AWS4-HMAC-SHA256',
+      'X-Amz-Credential': '${config.accessKeyId}/$scope',
+      'X-Amz-Date': amzDate,
+      'X-Amz-Expires': '$expiresIn',
+      'X-Amz-SignedHeaders': 'host',
+    };
+    final canonicalQuery = params.entries
+        .map((e) => '${_uriEncode(e.key)}=${_uriEncode(e.value)}')
+        .toList()
+      ..sort();
+    final queryString = canonicalQuery.join('&');
+
+    const payloadHash = 'UNSIGNED-PAYLOAD';
+    final canonicalHeaders = 'host:${uri.host}\n';
+    final canonicalRequest =
+        'GET\n${uri.path}\n$queryString\n$canonicalHeaders\nhost\n$payloadHash';
+    final stringToSign = _stringToSign(
+      amzDate,
+      scope,
+      canonicalRequest,
+    );
+    final signingKey = _signingKey(dateStamp, config.region);
+    final signature = _toHex(_hmac(signingKey, stringToSign));
+    return '${uri.scheme}://${uri.host}${uri.path}?$queryString'
+        '&X-Amz-Signature=$signature';
+  }
+
+  @override
+  Future<List<StorageObject>> listObjects([String? prefix]) async {
+    final base = _objectUri('').replace(path: '/${config.bucketName}/');
+    final listUri = base.replace(
+      queryParameters: {
+        'list-type': '2',
+        if (prefix != null && prefix.isNotEmpty) 'prefix': prefix,
+      },
+    );
+    final response = await _send('GET', listUri, body: null);
+    _assertStatus(response, [200], 'listObjects');
+    return _parseListObjects(response.body);
+  }
+
+  @override
+  Future<void> deleteObjects(List<String> keys) async {
+    for (final key in keys) {
+      await deleteObject(key);
+    }
+  }
+
+  // --- signing helpers -------------------------------------------------------
+
+  Map<String, String> _authHeaders(
+    String method,
+    Uri uri,
+    List<int>? body,
+  ) {
+    final now = DateTime.now().toUtc();
+    final amzDate = _amzDate(now);
+    final dateStamp = amzDate.substring(0, 8);
+    final scope = '$dateStamp/${config.region}/$_service/aws4_request';
+    final payloadHash = body == null ? _hashHex(const []) : _hashHex(body);
+
+    final canonicalHeaders = 'host:${uri.host}\n'
+        'x-amz-content-sha256:$payloadHash\n'
+        'x-amz-date:$amzDate\n';
+    const signedHeaders = 'host;x-amz-content-sha256;x-amz-date';
+
+    final canonicalRequest = '$method\n${uri.path}\n'
+        '\n$canonicalHeaders$signedHeaders\n$payloadHash';
+    final stringToSign = _stringToSign(amzDate, scope, canonicalRequest);
+    final signingKey = _signingKey(dateStamp, config.region);
+    final signature = _toHex(_hmac(signingKey, stringToSign));
+
+    return {
+      'x-amz-date': amzDate,
+      'x-amz-content-sha256': payloadHash,
+      'Authorization':
+          'AWS4-HMAC-SHA256 Credential=${config.accessKeyId}/$scope, '
+          'SignedHeaders=$signedHeaders, Signature=$signature',
+    };
+  }
+
+  Future<Response> _send(
+    String method,
+    Uri uri, {
+    required List<int>? body,
+    Map<String, String>? extraHeaders,
+  }) async {
+    final request = Request(method, uri);
+    request.headers.addAll(_authHeaders(method, uri, body));
+    if (extraHeaders != null) request.headers.addAll(extraHeaders);
+    if (body != null) request.bodyBytes = body;
+    final streamed = await _http.send(request);
+    return await Response.fromStream(streamed);
+  }
+
+  List<StorageObject> _parseListObjects(String xml) {
+    final objects = <StorageObject>[];
+    final contents = _allMatches(xml, RegExp(r'<Contents>([\s\S]*?)</Contents>'));
+    for (final block in contents) {
+      final key = _tag(block, 'Key');
+      final size = int.tryParse(_tag(block, 'Size') ?? '');
+      final lastModified = _tag(block, 'LastModified');
+      if (key == null) continue;
+      objects.add(
+        StorageObject(
+          key: key,
+          storageUri: 'r2://${config.bucketName}/$key',
+          size: size ?? 0,
+          lastModifiedAt: lastModified == null
+              ? null
+              : DateTime.tryParse(lastModified),
+        ),
+      );
+    }
+    return objects;
+  }
+
+  // --- low-level sigv4 primitives --------------------------------------------
+
+  List<int> _signingKey(String dateStamp, String region) {
+    var key = utf8.encode('AWS4${config.secretAccessKey}');
+    key = _hmac(key, dateStamp);
+    key = _hmac(key, region);
+    key = _hmac(key, _service);
+    key = _hmac(key, 'aws4_request');
+    return key;
+  }
+
+  String _stringToSign(String amzDate, String scope, String canonicalRequest) =>
+      'AWS4-HMAC-SHA256\n$amzDate\n$scope\n${_hashHex(utf8.encode(canonicalRequest))}';
+
+  // --- static utilities ------------------------------------------------------
+
+  static String _amzDate(DateTime utc) =>
+      '${utc.toIso8601String().replaceAll('-', '').replaceAll(':', '').split('.').first}Z';
+
+  static String _uriEncode(String value) => Uri.encodeQueryComponent(value);
+
+  static Uint8List _hmac(List<int> key, String data) =>
+      Hmac(sha256, key).convert(utf8.encode(data)).bytes as Uint8List;
+
+  static String _hashHex(List<int> data) => _toHex(sha256.convert(data).bytes);
+
+  static String _toHex(List<int> bytes) =>
+      bytes.map((b) => b.toRadixString(16).padLeft(2, '0')).join();
+
+  static List<String> _allMatches(String input, RegExp regex) =>
+      regex.allMatches(input).map((m) => m.group(1)!).toList();
+
+  static String? _tag(String block, String name) {
+    final m = RegExp('<$name>([\\s\\S]*?)</$name>').firstMatch(block);
+    return m?.group(1);
+  }
+
+  static void _assertStatus(
+    Response response,
+    List<int> ok,
+    String operation,
+  ) {
+    if (!ok.contains(response.statusCode)) {
+      throw Exception(
+        'R2 $operation failed (${response.statusCode}): ${response.body}',
+      );
+    }
+  }
+}
+
+/// Read a local file's bytes (node profile helper).
+Future<List<int>> readFileBytes(String filePath) =>
+    File(filePath).readAsBytes();
+
+/// Write bytes to a local file, creating parent directories.
+Future<void> writeFileBytes(String filePath, List<int> bytes) async {
+  final file = File(filePath);
+  await file.parent.create(recursive: true);
+  await file.writeAsBytes(bytes);
+}

package/dart-src/plugins/cloudflare/lib/src/r2_storage.dart

@@ -0,0 +1,23 @@
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show StoragePlugin, createUniversalStoragePlugin;
+
+import 'r2_config.dart' show R2S3StorageConfig;
+import 'r2_storage_profile.dart'
+    show createS3RuntimeStorageProfile, createS3StorageProfile;
+
+/// Cloudflare R2 storage plugin (faithful port of hot-updater's `r2Storage`).
+///
+/// Uses the S3-compatible R2 API (AWS Signature V4). The node profile handles
+/// upload/delete/download/list; the runtime profile serves presigned download
+/// URLs and reads small text objects. Note: hot-updater also supports a
+/// deprecated Wrangler-CLI based profile; only the S3-compatible profile is
+/// ported here.
+final StoragePlugin Function(R2S3StorageConfig config) r2Storage =
+    createUniversalStoragePlugin<R2S3StorageConfig>(
+  name: 'r2Storage',
+  supportedProtocol: 'r2',
+  factory: (config) => (
+    node: createS3StorageProfile(config),
+    runtime: createS3RuntimeStorageProfile(config),
+  ),
+);