@_nazmiforreal/flutter-ota 0.1.0 → 0.1.2

package/dart-src/plugins/aws/lib/src/with_cloudfront_signed_url.dart

@@ -0,0 +1,136 @@
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show
+        RuntimeStorageProfile,
+        StoragePlugin,
+        StoragePluginProfiles;
+
+import 'aws_cloudfront_signer.dart' show cloudfrontSignedUrl;
+import 'aws_ssm_client.dart' show AwsSsmClient;
+
+const int _oneYearInSeconds = 60 * 60 * 24 * 365;
+
+/// Configuration for wrapping a storage plugin with CloudFront signed URLs.
+///
+/// Faithful port of hot-updater `WithCloudFrontSignedUrlOptions` (minus the
+/// `TContext` generic, which the Dart runtime profile does not expose).
+class WithCloudFrontSignedUrlOptions {
+  const WithCloudFrontSignedUrlOptions({
+    required this.keyPairId,
+    this.publicBaseUrl,
+    this.publicBaseUrlResolver,
+    this.getPrivateKey,
+    this.ssmParameterName,
+    this.ssmRegion,
+    this.expiresSeconds,
+    this.accessKeyId,
+    this.secretAccessKey,
+    this.sessionToken,
+  });
+
+  final String keyPairId;
+  final String? publicBaseUrl;
+  final Future<String> Function()? publicBaseUrlResolver;
+  final Future<String> Function()? getPrivateKey;
+  final String? ssmParameterName;
+  final String? ssmRegion;
+  final int? expiresSeconds;
+  final String? accessKeyId;
+  final String? secretAccessKey;
+  final String? sessionToken;
+}
+
+/// Wrap a storage plugin factory so that `s3://` download URLs are rewritten as
+/// CloudFront signed URLs. Faithful port of `withCloudFrontSignedUrl.ts`.
+StoragePlugin Function() withCloudFrontSignedUrl(
+  StoragePlugin Function() storageFactory,
+  WithCloudFrontSignedUrlOptions config,
+) {
+  return () {
+    final base = storageFactory();
+    final runtime = base.profiles.runtime == null
+        ? null
+        : _CloudFrontSignedRuntimeProfile(base.profiles.runtime!, config);
+    return _CloudFrontSignedStoragePlugin(base, runtime);
+  };
+}
+
+class _CloudFrontSignedStoragePlugin implements StoragePlugin {
+  _CloudFrontSignedStoragePlugin(this._base, this._runtime);
+
+  final StoragePlugin _base;
+  final RuntimeStorageProfile? _runtime;
+
+  @override
+  String get name => '${_base.name}WithCloudFrontSignedUrl';
+
+  @override
+  String get supportedProtocol => _base.supportedProtocol;
+
+  @override
+  StoragePluginProfiles get profiles => StoragePluginProfiles(
+        node: _base.profiles.node,
+        runtime: _runtime,
+      );
+}
+
+class _CloudFrontSignedRuntimeProfile implements RuntimeStorageProfile {
+  _CloudFrontSignedRuntimeProfile(this._base, this._config);
+
+  final RuntimeStorageProfile _base;
+  final WithCloudFrontSignedUrlOptions _config;
+
+  @override
+  Future<Map<String, String>> getDownloadUrl(String storageUri) async {
+    final parsed = Uri.parse(storageUri);
+    if (parsed.scheme != 's3') {
+      return _base.getDownloadUrl(storageUri);
+    }
+
+    final privateKey = await _resolvePrivateKey();
+    final publicBaseUrl = await _resolvePublicBaseUrl();
+    final url = Uri.parse(publicBaseUrl);
+    final signedUrl = cloudfrontSignedUrl(
+      url: url.replace(path: parsed.path, query: null).toString(),
+      keyPairId: _config.keyPairId,
+      privateKeyPem: privateKey,
+      dateLessThan: DateTime.now().add(
+        Duration(seconds: _config.expiresSeconds ?? _oneYearInSeconds),
+      ),
+    );
+    return {'fileUrl': signedUrl};
+  }
+
+  @override
+  Future<String?> readText(String storageUri) => _base.readText(storageUri);
+
+  Future<String> _resolvePrivateKey() async {
+    if (_config.getPrivateKey != null) return _config.getPrivateKey!();
+    if (_config.ssmParameterName != null && _config.ssmRegion != null) {
+      final ssm = AwsSsmClient(
+        region: _config.ssmRegion!,
+        accessKeyId: _config.accessKeyId ?? '',
+        secretAccessKey: _config.secretAccessKey ?? '',
+        sessionToken: _config.sessionToken,
+      );
+      return ssm.getParameter(_config.ssmParameterName!);
+    }
+    throw StateError(
+      'withCloudFrontSignedUrl: no private key source configured '
+      '(provide getPrivateKey or ssmParameterName/ssmRegion).',
+    );
+  }
+
+  Future<String> _resolvePublicBaseUrl() async {
+    if (_config.publicBaseUrlResolver != null) {
+      final value = await _config.publicBaseUrlResolver!();
+      if (value.isEmpty) {
+        throw StateError('CloudFront publicBaseUrl resolver returned empty URL');
+      }
+      return value;
+    }
+    if (_config.publicBaseUrl != null && _config.publicBaseUrl!.isNotEmpty) {
+      return _config.publicBaseUrl!;
+    }
+    throw StateError('CloudFront publicBaseUrl is empty');
+  }
+}

package/dart-src/plugins/aws/pubspec.yaml

@@ -0,0 +1,22 @@
+name: flutter_patcher_aws
+description: AWS S3 storage + S3/DynamoDB database plugins for flutter_patcher (faithful port of hot-updater plugins/aws).
+version: 0.1.0
+publish_to: none
+
+environment:
+  sdk: ">=3.3.0 <4.0.0"
+
+dependencies:
+  flutter_patcher_core:
+    path: ../../packages/core
+  flutter_patcher_plugin_core:
+    path: ../../plugins/plugin-core
+  crypto: ^3.0.0
+  http: ^1.2.0
+  path: ^1.9.0
+  pointycastle: ^3.9.1
+  asn1lib: ^1.5.4
+
+dev_dependencies:
+  test: ^1.25.0
+  lints: ^4.0.0

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

@@ -0,0 +1,18 @@
+library;
+
+export 'src/d1_bundle_mapper.dart'
+    show
+        buildBundlePatchId,
+        bundleToPatchRows,
+        defaultRolloutCohortCount,
+        parseMetadata,
+        parseTargetCohorts,
+        transformRowToBundle;
+export 'src/d1_client.dart' show D1Client, D1ClientLike;
+export 'src/d1_config.dart' show D1ClientFactory, D1DatabaseConfig, resolveD1Client;
+export 'src/d1_database.dart' show d1Database;
+export 'src/cloudflare_worker_database.dart'
+    show CloudflareWorkerDatabaseConfig, cloudflareWorkerDatabase;
+export 'src/r2_config.dart' show R2S3ClientFactory, R2S3StorageConfig, resolveR2Client;
+export 'src/r2_s3_client.dart' show R2S3Client, R2S3ClientLike;
+export 'src/r2_storage.dart' show r2Storage;

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

@@ -0,0 +1,29 @@
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show createDatabasePlugin;
+
+import 'd1_client.dart' show D1ClientLike;
+import 'd1_database_plugin.dart' show D1DatabasePlugin;
+
+/// Configuration for the Cloudflare Workers D1 database plugin.
+///
+/// Mirrors hot-updater's `CloudflareWorkerDatabaseConfig`: instead of talking
+/// to D1 over the REST API, the plugin uses a `D1Like` binding supplied by
+/// [getDb] (the Workers runtime `env.DB`). In the Dart port the binding is
+/// represented by a [D1ClientLike], which makes it trivially testable by
+/// injecting a mock.
+class CloudflareWorkerDatabaseConfig {
+  const CloudflareWorkerDatabaseConfig({required this.getDb});
+
+  final D1ClientLike Function() getDb;
+}
+
+/// Cloudflare Workers D1 database plugin (faithful port of hot-updater's
+/// `cloudflareWorkerDatabase`).
+///
+/// Shares the exact same SQL/update-info logic as [d1Database]; only the
+/// client source differs (an in-process D1 binding instead of the REST API).
+final cloudflareWorkerDatabase =
+    createDatabasePlugin<CloudflareWorkerDatabaseConfig>(
+  name: 'd1WorkerDatabase',
+  factory: (config) => D1DatabasePlugin(config.getDb()),
+);

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

@@ -0,0 +1,93 @@
+import 'dart:convert' show jsonEncode;
+
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show DatabaseBundleQueryWhere;
+
+/// Result of building a WHERE clause: SQL fragment plus positional params.
+class _BuildWhereResult {
+  const _BuildWhereResult(this.sql, this.params);
+
+  final String sql;
+  final List<dynamic> params;
+}
+
+/// Build a SQLite WHERE clause with positional `?` params, mirroring
+/// `buildWhereClause` from hot-updater's `d1Database.ts`.
+_BuildWhereResult buildWhereClause(DatabaseBundleQueryWhere conditions) {
+  final clauses = <String>[];
+  final params = <dynamic>[];
+
+  String jsonEachIn(String columnName, List<String> values) {
+    if (values.isEmpty) return '1 = 0';
+    params.add(jsonEncode(values));
+    return '$columnName IN (SELECT value FROM json_each(?))';
+  }
+
+  if (conditions.channel != null) {
+    clauses.add('channel = ?');
+    params.add(conditions.channel);
+  }
+
+  if (conditions.platform != null) {
+    clauses.add('platform = ?');
+    params.add(conditions.platform!.value);
+  }
+
+  if (conditions.enabled != null) {
+    clauses.add('enabled = ?');
+    params.add(conditions.enabled! ? 1 : 0);
+  }
+
+  if (conditions.id?.ins != null) {
+    clauses.add(jsonEachIn('id', conditions.id!.ins!));
+  }
+
+  if (conditions.id?.eq != null) {
+    clauses.add('id = ?');
+    params.add(conditions.id!.eq);
+  }
+
+  if (conditions.id?.gt != null) {
+    clauses.add('id > ?');
+    params.add(conditions.id!.gt);
+  }
+
+  if (conditions.id?.gte != null) {
+    clauses.add('id >= ?');
+    params.add(conditions.id!.gte);
+  }
+
+  if (conditions.id?.lt != null) {
+    clauses.add('id < ?');
+    params.add(conditions.id!.lt);
+  }
+
+  if (conditions.id?.lte != null) {
+    clauses.add('id <= ?');
+    params.add(conditions.id!.lte);
+  }
+
+  if (conditions.targetAppVersionNotNull == true) {
+    clauses.add('target_app_version IS NOT NULL');
+  }
+
+  if (conditions.targetAppVersion != null) {
+    clauses.add('target_app_version = ?');
+    params.add(conditions.targetAppVersion);
+  }
+
+  if (conditions.targetAppVersionIn != null) {
+    clauses.add(
+      jsonEachIn('target_app_version', conditions.targetAppVersionIn!),
+    );
+  }
+
+  if (conditions.fingerprintHash != null) {
+    clauses.add('fingerprint_hash = ?');
+    params.add(conditions.fingerprintHash);
+  }
+
+  final whereClause =
+      clauses.isNotEmpty ? ' WHERE ${clauses.join(' AND ')}' : '';
+  return _BuildWhereResult(whereClause, params);
+}

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

@@ -0,0 +1,131 @@
+import 'dart:convert' show jsonDecode;
+
+import 'package:flutter_patcher_core/flutter_patcher_core.dart'
+    show Bundle, BundleMetadata, BundlePatchArtifact, Platform, getBundlePatches;
+
+/// Default rollout cohort count — full rollout in the Dart port's per-mille
+/// scale (matches core's `defaultRolloutCohortCount` = `numericCohortSize`).
+const int defaultRolloutCohortCount = 1000;
+
+/// Compound patch id `${bundleId}:${baseBundleId}` (matches D1 schema).
+String buildBundlePatchId(String bundleId, String baseBundleId) =>
+    '$bundleId:$baseBundleId';
+
+/// Parse `target_cohorts` which is stored as a JSON string (or already a list).
+List<String>? parseTargetCohorts(dynamic value) {
+  if (value == null) return null;
+  if (value is List) {
+    return [
+      for (final v in value)
+        if (v is String) v,
+    ];
+  }
+  if (value is String) {
+    try {
+      final parsed = jsonDecode(value);
+      if (parsed is List) {
+        return [
+          for (final v in parsed)
+            if (v is String) v,
+        ];
+      }
+    } catch (_) {
+      return null;
+    }
+  }
+  return null;
+}
+
+/// Parse `metadata` which may be a JSON string or an already-decoded object.
+Map<String, Object?>? parseMetadata(dynamic value) {
+  if (value == null) return null;
+  if (value is String) {
+    try {
+      return parseMetadata(jsonDecode(value));
+    } catch (_) {
+      return null;
+    }
+  }
+  if (value is Map) {
+    return value.cast<String, Object?>();
+  }
+  return null;
+}
+
+/// Convert a [Bundle] into the rows inserted into `bundle_patches`.
+List<Map<String, dynamic>> bundleToPatchRows(Bundle bundle) =>
+    getBundlePatches(bundle).asMap().entries.map((entry) {
+      final patch = entry.value;
+      return {
+        'id': buildBundlePatchId(bundle.id, patch.baseBundleId),
+        'bundle_id': bundle.id,
+        'base_bundle_id': patch.baseBundleId,
+        'base_file_hash': patch.baseFileHash,
+        'patch_file_hash': patch.patchFileHash,
+        'patch_storage_uri': patch.patchStorageUri,
+        'order_index': entry.key,
+      };
+    }).toList();
+
+/// Rebuild a [Bundle] from a D1 `bundles` row plus its `bundle_patches` rows.
+Bundle transformRowToBundle(
+  Map<String, dynamic> row, [
+  List<Map<String, dynamic>> patchRows = const [],
+]) {
+  final rawMetadata = parseMetadata(row['metadata']);
+  final metadata = rawMetadata == null
+      ? null
+      : BundleMetadata.fromJson(rawMetadata.cast<String, dynamic>());
+  final patches = patchRows
+      .toList()
+    ..sort(
+      (left, right) =>
+          (left['order_index'] as num? ?? 0)
+              .compareTo(right['order_index'] as num? ?? 0) +
+          (left['base_bundle_id'] as String? ?? '')
+              .compareTo(right['base_bundle_id'] as String? ?? ''),
+    );
+
+  final bundlePatches = patches.map((patch) {
+    return BundlePatchArtifact(
+      baseBundleId: patch['base_bundle_id'] as String,
+      baseFileHash: patch['base_file_hash'] as String,
+      patchFileHash: patch['patch_file_hash'] as String,
+      patchStorageUri: patch['patch_storage_uri'] as String,
+    );
+  }).toList();
+
+  final primaryPatch = bundlePatches.isNotEmpty ? bundlePatches.first : null;
+
+  final enabled = row['enabled'];
+  final shouldForceUpdate = row['should_force_update'];
+
+  return Bundle(
+    id: row['id'] as String,
+    channel: row['channel'] as String,
+    enabled: enabled is bool ? enabled : (enabled as num? ?? 0) != 0,
+    shouldForceUpdate: shouldForceUpdate is bool
+        ? shouldForceUpdate
+        : (shouldForceUpdate as num? ?? 0) != 0,
+    fileHash: row['file_hash'] as String,
+    gitCommitHash: row['git_commit_hash'] as String?,
+    message: row['message'] as String?,
+    platform: Platform.fromValue(row['platform'] as String),
+    targetAppVersion: row['target_app_version'] as String?,
+    storageUri: row['storage_uri'] as String,
+    fingerprintHash: row['fingerprint_hash'] as String?,
+    metadata: metadata,
+    manifestStorageUri: row['manifest_storage_uri'] as String?,
+    manifestFileHash: row['manifest_file_hash'] as String?,
+    assetBaseStorageUri: row['asset_base_storage_uri'] as String?,
+    patches: bundlePatches,
+    patchBaseBundleId: primaryPatch?.baseBundleId,
+    patchBaseFileHash: primaryPatch?.baseFileHash,
+    patchFileHash: primaryPatch?.patchFileHash,
+    patchStorageUri: primaryPatch?.patchStorageUri,
+    rolloutCohortCount:
+        (row['rollout_cohort_count'] as num? ?? defaultRolloutCohortCount)
+            .toInt(),
+    targetCohorts: parseTargetCohorts(row['target_cohorts']),
+  );
+}

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

@@ -0,0 +1,66 @@
+import 'dart:convert' show jsonDecode, jsonEncode;
+
+import 'package:http/http.dart' show Client;
+
+import 'd1_config.dart' show D1DatabaseConfig;
+
+/// A thin client over a Cloudflare D1 database.
+///
+/// Mirrors the `cf.d1.database.query(databaseId, { account_id, sql, params })`
+/// call from hot-updater's cloudflare plugin: each call issues a single SQL
+/// statement with positional `?` parameters and returns the flattened result
+/// rows as JSON maps.
+abstract class D1ClientLike {
+  const D1ClientLike();
+
+  Future<List<Map<String, dynamic>>> query(
+    String sql, [
+    List<dynamic> params = const [],
+  ]);
+}
+
+/// Real D1 client backed by the Cloudflare REST API.
+class D1Client implements D1ClientLike {
+  D1Client(this.config, {Client? http}) : _http = http ?? Client();
+
+  final D1DatabaseConfig config;
+  final Client _http;
+
+  @override
+  Future<List<Map<String, dynamic>>> query(
+    String sql, [
+    List<dynamic> params = const [],
+  ]) async {
+    final uri = Uri.https(
+      'api.cloudflare.com',
+      '/client/v4/accounts/${config.accountId}/d1/database/${config.databaseId}/query',
+    );
+
+    final response = await _http.post(
+      uri,
+      headers: {
+        'Authorization': 'Bearer ${config.cloudflareApiToken}',
+        'Content-Type': 'application/json',
+      },
+      body: jsonEncode({'sql': sql, 'params': params}),
+    );
+
+    if (response.statusCode < 200 || response.statusCode >= 300) {
+      throw Exception(
+        'Cloudflare D1 query failed (${response.statusCode}): ${response.body}',
+      );
+    }
+
+    final decoded = jsonDecode(response.body) as Map<String, dynamic>;
+    final result = (decoded['result'] as List?) ?? const <dynamic>[];
+
+    final rows = <Map<String, dynamic>>[];
+    for (final page in result.cast<Map<String, dynamic>>()) {
+      final pageResults = (page['results'] as List?) ?? const <dynamic>[];
+      for (final row in pageResults) {
+        rows.add((row as Map).cast<String, dynamic>());
+      }
+    }
+    return rows;
+  }
+}

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

@@ -0,0 +1,30 @@
+import 'd1_client.dart' show D1Client, D1ClientLike;
+
+/// Configuration for the Cloudflare D1 database plugin.
+class D1DatabaseConfig {
+  const D1DatabaseConfig({
+    required this.databaseId,
+    required this.accountId,
+    required this.cloudflareApiToken,
+    this.clientFactory,
+  });
+
+  /// Cloudflare D1 database ID.
+  final String databaseId;
+
+  /// Cloudflare account ID.
+  final String accountId;
+
+  /// Cloudflare API token with D1 read/write permissions.
+  final String cloudflareApiToken;
+
+  /// Optional factory used to inject a [D1ClientLike] in tests.
+  final D1ClientFactory? clientFactory;
+}
+
+/// Builds a [D1ClientLike] for the given [D1DatabaseConfig].
+typedef D1ClientFactory = D1ClientLike Function(D1DatabaseConfig config);
+
+/// Resolves the client for a config, using the injected factory when present.
+D1ClientLike resolveD1Client(D1DatabaseConfig config) =>
+    config.clientFactory?.call(config) ?? D1Client(config);

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

@@ -0,0 +1,16 @@
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show createDatabasePlugin;
+
+import 'd1_config.dart' show D1DatabaseConfig, resolveD1Client;
+import 'd1_database_plugin.dart' show D1DatabasePlugin;
+
+/// Cloudflare D1 database plugin over the REST API (faithful port of
+/// hot-updater's `d1Database`).
+///
+/// Issues raw SQLite statements against Cloudflare D1 over the REST API and
+/// resolves update information in-process via [resolveUpdateInfoFromBundles]
+/// (no SQL stored procedures, unlike the Supabase/Postgres backends).
+final d1Database = createDatabasePlugin<D1DatabaseConfig>(
+  name: 'd1Database',
+  factory: (config) => D1DatabasePlugin(resolveD1Client(config)),
+);