@_nazmiforreal/flutter-ota 0.1.0 → 0.1.2

package/dart-src/plugins/standalone/lib/src/standalone_database.dart

@@ -0,0 +1,233 @@
+import 'dart:convert' show jsonDecode, jsonEncode;
+
+import 'package:flutter_patcher_core/flutter_patcher_core.dart'
+    show
+        AppVersionGetBundlesArgs,
+        Bundle,
+        FingerprintGetBundlesArgs,
+        GetBundlesArgs,
+        UpdateInfo,
+        UpdateStatus;
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show
+        AbstractDatabasePlugin,
+        BundleChange,
+        BundleChangeOperation,
+        DatabaseBundleQueryOptions,
+        Paginated,
+        PaginationInfo,
+        createDatabasePlugin;
+import 'package:http/http.dart' as http;
+import 'package:http/http.dart';
+
+import 'standalone_config.dart'
+    show
+        StandaloneRepositoryConfig,
+        StandaloneRepositoryRoutes,
+        buildPath,
+        joinUrl,
+        mergeHeaders;
+
+/// Double-curried standalone repository factory.
+///
+/// Faithful port of hot-updater `plugins/standalone/src/standaloneRepository.ts`.
+DatabasePluginLike standaloneRepository(
+  StandaloneRepositoryConfig config, [
+  Object? hooks,
+]) =>
+    createDatabasePlugin<StandaloneRepositoryConfig>(
+      name: 'standalone-repository',
+      factory: (c) => _StandaloneRepository(c),
+    )(config);
+
+/// Alias so the curried factory can be used uniformly with other backends.
+typedef DatabasePluginLike = dynamic;
+
+class _StandaloneRepository implements AbstractDatabasePlugin {
+  _StandaloneRepository(this.config)
+      : routes = config.routes ?? const StandaloneRepositoryRoutes();
+
+  final StandaloneRepositoryConfig config;
+  final StandaloneRepositoryRoutes routes;
+
+  Client _client() => config.clientFactory?.call() ?? http.Client();
+
+  Map<String, String> _headers([Map<String, String>? extra]) =>
+      mergeHeaders(config.commonHeaders, extra);
+
+  Future<dynamic> _decode(Response res) {
+    if (res.statusCode >= 400) {
+      throw StateError(
+        'standalone repository request failed (${res.statusCode}): '
+        '${res.body}',
+      );
+    }
+    return Future.value(jsonDecode(res.body));
+  }
+
+  @override
+  bool get supportsCursorPagination => true;
+
+  @override
+  Future<List<String>> getChannels() async {
+    final client = _client();
+    final res = await client.get(
+      Uri.parse(joinUrl(config.baseUrl, routes.channels)),
+      headers: _headers({'Cache-Control': 'no-cache'}),
+    );
+    final decoded = await _decode(res) as Map<String, dynamic>;
+    final data = decoded['data'] as Map<String, dynamic>;
+    final channels = (data['channels'] as List?)?.cast<String>() ?? const [];
+    return channels;
+  }
+
+  @override
+  Future<Bundle?> getBundleById(String bundleId) async {
+    final client = _client();
+    final res = await client.get(
+      Uri.parse(joinUrl(config.baseUrl, buildPath(routes.retrieve, id: bundleId))),
+      headers: _headers({'Accept': 'application/json'}),
+    );
+    if (res.statusCode == 404) return null;
+    final decoded = await _decode(res);
+    return Bundle.fromJson(decoded as Map<String, dynamic>);
+  }
+
+  @override
+  Future<Paginated<List<Bundle>>> getBundles(
+    DatabaseBundleQueryOptions options,
+  ) async {
+    final client = _client();
+    final query = <String, String>{};
+    final where = options.where;
+    if (where != null) {
+      if (where.channel != null) query['channel'] = where.channel!;
+      if (where.platform != null) query['platform'] = where.platform!.value;
+      if (where.enabled != null) query['enabled'] = '${where.enabled}';
+      final id = where.id;
+      if (id != null) {
+        if (id.eq != null) query['idEq'] = id.eq!;
+        if (id.gt != null) query['idGt'] = id.gt!;
+        if (id.gte != null) query['idGte'] = id.gte!;
+        if (id.lt != null) query['idLt'] = id.lt!;
+        if (id.lte != null) query['idLte'] = id.lte!;
+        if (id.ins != null) query['idIn'] = id.ins!.join(',');
+      }
+      if (where.targetAppVersion != null) {
+        query['targetAppVersion'] = where.targetAppVersion!;
+      }
+      if (where.targetAppVersionIn != null) {
+        query['targetAppVersionIn'] = where.targetAppVersionIn!.join(',');
+      }
+      if (where.targetAppVersionNotNull != null) {
+        query['targetAppVersionNotNull'] = '${where.targetAppVersionNotNull}';
+      }
+      if (where.fingerprintHash != null) {
+        query['fingerprintHash'] = where.fingerprintHash!;
+      }
+    }
+    query['limit'] = '${options.limit}';
+    if (options.page != null) query['page'] = '${options.page}';
+    if (options.offset != null) query['offset'] = '${options.offset}';
+    if (options.cursor?.after != null) query['after'] = options.cursor!.after!;
+    if (options.cursor?.before != null) {
+      query['before'] = options.cursor!.before!;
+    }
+
+    final uri = Uri.parse(joinUrl(config.baseUrl, routes.list))
+        .replace(queryParameters: query);
+    final res = await client.get(
+      uri,
+      headers: _headers({'Cache-Control': 'no-cache'}),
+    );
+    final decoded = await _decode(res) as Map<String, dynamic>;
+    final data = (decoded['data'] as List?)?.cast<Map<String, dynamic>>() ?? [];
+    final bundles = data.map(Bundle.fromJson).toList();
+    final pagination =
+        (decoded['pagination'] as Map?)?.cast<String, dynamic>() ?? {};
+    return Paginated(
+      data: bundles,
+      pagination: PaginationInfo(
+        total: pagination['total'] as int? ?? bundles.length,
+        hasNextPage: pagination['hasNextPage'] as bool? ?? false,
+        hasPreviousPage: pagination['hasPreviousPage'] as bool? ?? false,
+        currentPage: pagination['currentPage'] as int? ?? 1,
+        totalPages: pagination['totalPages'] as int? ?? 1,
+        nextCursor: pagination['nextCursor'] as String?,
+        previousCursor: pagination['previousCursor'] as String?,
+      ),
+    );
+  }
+
+  @override
+  Future<void> commitBundle({
+    required List<BundleChange> changedSets,
+  }) async {
+    final client = _client();
+    for (final change in changedSets) {
+      final bundle = change.data;
+      switch (change.operation) {
+        case BundleChangeOperation.insert:
+          final res = await client.post(
+            Uri.parse(joinUrl(config.baseUrl, routes.create)),
+            headers: _headers({'Content-Type': 'application/json'}),
+            body: jsonEncode([bundle.toJson()]),
+          );
+          await _decode(res);
+        case BundleChangeOperation.update:
+          final res = await client.patch(
+            Uri.parse(joinUrl(config.baseUrl, buildPath(routes.update, id: bundle.id))),
+            headers: _headers({'Content-Type': 'application/json'}),
+            body: jsonEncode(bundle.toJson()),
+          );
+          await _decode(res);
+        case BundleChangeOperation.delete:
+          final res = await client.delete(
+            Uri.parse(joinUrl(config.baseUrl, buildPath(routes.delete, id: bundle.id))),
+          );
+          await _decode(res);
+      }
+    }
+  }
+
+  @override
+  Future<UpdateInfo?> getUpdateInfo(GetBundlesArgs args) async {
+    final client = _client();
+    final path = args is AppVersionGetBundlesArgs
+        ? _appVersionPath(args)
+        : _fingerprintPath(args);
+    final res = await client.get(
+      Uri.parse(joinUrl(config.baseUrl, path)),
+      headers: _headers({'Cache-Control': 'no-cache'}),
+    );
+    if (res.statusCode == 404) return null;
+    final decoded = await _decode(res) as Map<String, dynamic>;
+    if (decoded['status'] == 'UP_TO_DATE') return null;
+    return UpdateInfo(
+      id: decoded['id'] as String,
+      shouldForceUpdate: (decoded['shouldForceUpdate'] ?? false) as bool,
+      message: decoded['message'] as String?,
+      status: UpdateStatus.fromValue(
+        decoded['status'] as String? ?? 'update-available',
+      ),
+      storageUri: decoded['fileUrl'] as String?,
+      fileHash: decoded['fileHash'] as String?,
+    );
+  }
+
+  String _fingerprintPath(GetBundlesArgs args) {
+    final fp = args is FingerprintGetBundlesArgs ? args.fingerprintHash : 'unknown';
+    final cohort = args.cohort != null ? '/${args.cohort}' : '';
+    return '/api/fingerprint/${args.platform.value}/$fp/'
+        '${args.channel}/${args.minBundleId}/${args.bundleId}$cohort';
+  }
+
+  String _appVersionPath(AppVersionGetBundlesArgs args) {
+    final cohort = args.cohort != null ? '/${args.cohort}' : '';
+    return '/api/app-version/${args.platform.value}/${args.appVersion}/'
+        '${args.channel}/${args.minBundleId}/${args.bundleId}$cohort';
+  }
+
+  @override
+  Future<void> onUnmount() async {}
+}

package/dart-src/plugins/standalone/lib/src/standalone_storage.dart

@@ -0,0 +1,175 @@
+import 'dart:convert' show jsonDecode, jsonEncode;
+import 'dart:io' show File;
+
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show
+        NodeStorageProfile,
+        RuntimeStorageProfile,
+        StorageObject,
+        createUniversalStoragePlugin;
+import 'package:http/http.dart' as http;
+import 'package:http/http.dart';
+
+import 'standalone_config.dart'
+    show
+        StandaloneStorageConfig,
+        StandaloneStorageRoutes,
+        joinUrl,
+        mergeHeaders;
+
+/// Single-curried standalone storage factory.
+///
+/// Faithful port of hot-updater `plugins/standalone/src/standaloneStorage.ts`.
+StoragePluginLike standaloneStorage(StandaloneStorageConfig config) =>
+    createUniversalStoragePlugin<StandaloneStorageConfig>(
+      name: 'standalone-storage',
+      supportedProtocol: 'http',
+      factory: (c) {
+        final storage = _StandaloneStorage(c);
+        return (node: storage, runtime: storage);
+      },
+    )(config);
+
+/// Alias so the curried factory can be used uniformly with other backends.
+typedef StoragePluginLike = dynamic;
+
+class _StandaloneStorage implements NodeStorageProfile, RuntimeStorageProfile {
+  _StandaloneStorage(this.config)
+      : routes = config.routes ?? const StandaloneStorageRoutes();
+
+  final StandaloneStorageConfig config;
+  final StandaloneStorageRoutes routes;
+
+  Client _client() => config.clientFactory?.call() ?? http.Client();
+
+  Map<String, String> _headers([Map<String, String>? extra]) =>
+      mergeHeaders(config.commonHeaders, extra);
+
+  // --- Node profile ---------------------------------------------------------
+
+  @override
+  Future<Map<String, String>> upload(String key, String filePath) async {
+    final client = _client();
+    final bytes = await File(filePath).readAsBytes();
+    final uri = Uri.parse(joinUrl(config.baseUrl, routes.upload))
+        .replace(queryParameters: {'key': key});
+    final res = await client.post(
+      uri,
+      headers: _headers({'Content-Type': 'application/octet-stream'}),
+      body: bytes,
+    );
+    if (res.statusCode >= 400) {
+      throw StateError(
+        'standalone storage upload failed (${res.statusCode}): ${res.body}',
+      );
+    }
+    final decoded = jsonDecode(res.body) as Map<String, dynamic>;
+    final storageUri = decoded['storageUri'] as String?;
+    if (storageUri == null) {
+      throw StateError('standalone storage upload returned no storageUri');
+    }
+    return {'storageUri': storageUri};
+  }
+
+  @override
+  Future<bool> exists(String storageUri) async {
+    final fileUrl = (await getDownloadUrl(storageUri))['fileUrl'];
+    if (fileUrl == null) return false;
+    final client = _client();
+    final res = await client.head(Uri.parse(fileUrl));
+    return res.statusCode >= 200 && res.statusCode < 300;
+  }
+
+  @override
+  Future<void> delete(String storageUri) async {
+    final client = _client();
+    final res = await client.delete(
+      Uri.parse(joinUrl(config.baseUrl, routes.delete)),
+      headers: _headers({'Content-Type': 'application/json'}),
+      body: jsonEncode({'storageUri': storageUri}),
+    );
+    if (res.statusCode >= 400) {
+      throw StateError(
+        'standalone storage delete failed (${res.statusCode}): ${res.body}',
+      );
+    }
+  }
+
+  @override
+  Future<void> downloadFile(String storageUri, String filePath) async {
+    final fileUrl = (await getDownloadUrl(storageUri))['fileUrl'];
+    if (fileUrl == null) {
+      throw StateError('standalone storage could not resolve download url');
+    }
+    final client = _client();
+    final res = await client.get(Uri.parse(fileUrl));
+    if (res.statusCode >= 400) {
+      throw StateError(
+        'standalone storage download failed (${res.statusCode})',
+      );
+    }
+    await File(filePath).writeAsBytes(res.bodyBytes);
+  }
+
+  @override
+  Future<List<StorageObject>> listObjects([String? prefix]) async {
+    final client = _client();
+    final uri = Uri.parse(joinUrl(config.baseUrl, routes.list))
+        .replace(queryParameters: prefix != null ? {'prefix': prefix} : null);
+    final res = await client.get(uri);
+    if (res.statusCode >= 400) return const [];
+    final decoded = jsonDecode(res.body) as Map<String, dynamic>;
+    final data = (decoded['data'] as List?)?.cast<Map<String, dynamic>>() ?? [];
+    return data
+        .map((o) => StorageObject(
+              key: o['key'] as String,
+              storageUri: o['storageUri'] as String,
+              size: o['size'] as int? ?? 0,
+            ))
+        .toList();
+  }
+
+  @override
+  Future<void> deleteObjects(List<String> keys) async {
+    for (final key in keys) {
+      await delete(key);
+    }
+  }
+
+  // --- Runtime profile ------------------------------------------------------
+
+  @override
+  Future<Map<String, String>> getDownloadUrl(String storageUri) async {
+    final client = _client();
+    final res = await client.post(
+      Uri.parse(joinUrl(config.baseUrl, routes.getDownloadUrl)),
+      headers: _headers({'Content-Type': 'application/json'}),
+      body: jsonEncode({'storageUri': storageUri}),
+    );
+    if (res.statusCode >= 400) {
+      throw StateError(
+        'standalone storage getDownloadUrl failed (${res.statusCode}): '
+        '${res.body}',
+      );
+    }
+    final decoded = jsonDecode(res.body) as Map<String, dynamic>;
+    final fileUrl = decoded['fileUrl'] as String?;
+    if (fileUrl == null) {
+      throw StateError('standalone storage getDownloadUrl returned no fileUrl');
+    }
+    return {'fileUrl': fileUrl};
+  }
+
+  @override
+  Future<String?> readText(String storageUri) async {
+    final client = _client();
+    final res = await client.post(
+      Uri.parse(joinUrl(config.baseUrl, routes.readText)),
+      headers: _headers({'Content-Type': 'application/json'}),
+      body: jsonEncode({'storageUri': storageUri}),
+    );
+    if (res.statusCode >= 400) return null;
+    final decoded = jsonDecode(res.body) as Map<String, dynamic>;
+    return decoded['data'] as String?;
+  }
+}

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

@@ -0,0 +1,18 @@
+name: flutter_patcher_standalone
+description: Standalone self-hosted backend for flutter_patcher (REST repository + storage).
+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
+  http: ^1.2.0
+
+dev_dependencies:
+  test: ^1.25.0
+  lints: ^4.0.0

package/dart-src/plugins/supabase/lib/edge.dart

@@ -0,0 +1,10 @@
+/// Edge-function entrypoint for flutter_patcher_supabase.
+///
+/// Mirrors hot-updater's `plugins/supabase/src/edge.ts`: exposes only the
+/// edge-runnable variants (runtime-only database + storage plugins).
+library;
+
+export 'src/supabase_edge_function_database.dart'
+    show supabaseEdgeFunctionDatabase, SupabaseEdgeFunctionDatabaseConfig;
+export 'src/supabase_edge_function_storage.dart'
+    show supabaseEdgeFunctionStorage, SupabaseEdgeFunctionStorageConfig;

package/dart-src/plugins/supabase/lib/flutter_patcher_supabase.dart

@@ -0,0 +1,21 @@
+/// flutter_patcher_supabase — Supabase backend for flutter_patcher.
+///
+/// Faithful Dart translation of hot-updater's `plugins/supabase`:
+/// database + storage plugins (direct + edge-function variants) over the
+/// Supabase REST (PostgREST) API.
+library;
+
+export 'src/supabase_config.dart';
+export 'src/supabase_client_adapter.dart'
+    show SupabaseClientLike, SupabaseClientFactory;
+export 'src/supabase_client_http.dart' show createSupabaseHttpClient;
+export 'src/supabase_database.dart'
+    show supabaseDatabase, SupabaseDatabaseConfig;
+export 'src/supabase_storage.dart'
+    show supabaseStorage, SupabaseStorageConfig, parseSupabaseStorageUri;
+export 'src/supabase_signed_url_batcher.dart'
+    show createSupabaseSignedUrlBatcher, ResolveSignedUrl;
+export 'src/supabase_edge_function_database.dart'
+    show supabaseEdgeFunctionDatabase, SupabaseEdgeFunctionDatabaseConfig;
+export 'src/supabase_edge_function_storage.dart'
+    show supabaseEdgeFunctionStorage, SupabaseEdgeFunctionStorageConfig;

package/dart-src/plugins/supabase/lib/src/supabase_bundle_mapper.dart

@@ -0,0 +1,129 @@
+/// Faithful port of hot-updater `plugins/supabase/src/supabaseBundleMapper.ts`.
+library;
+
+import 'dart:convert';
+
+import 'package:flutter_patcher_core/flutter_patcher_core.dart';
+
+import 'types.dart';
+
+const String bundleSelectColumns =
+    'id, channel, enabled, platform, should_force_update, file_hash, '
+    'git_commit_hash, message, fingerprint_hash, target_app_version, '
+    'storage_uri, metadata, manifest_storage_uri, manifest_file_hash, '
+    'asset_base_storage_uri, rollout_cohort_count, target_cohorts';
+
+/// Normalize metadata from various shapes to a plain map.
+Map<String, Object?>? _normalizeMetadata(Object? value) {
+  if (value == null) return null;
+
+  if (value is String) {
+    try {
+      final parsed = jsonDecode(value);
+      return _normalizeMetadata(parsed);
+    } catch (_) {
+      return null;
+    }
+  }
+
+  if (value is Map) return value.cast<String, Object?>();
+
+  return null;
+}
+
+/// Build the compound primary key for a patch row.
+String _buildBundlePatchId(String bundleId, String baseBundleId) =>
+    '$bundleId:$baseBundleId';
+
+/// Map a Supabase bundle row + optional patch rows to a [Bundle].
+Bundle mapRowToBundle(
+  SupabaseBundleRow row, [
+  List<SupabaseBundlePatchRow> patchRows = const [],
+]) {
+  final rawMetadata = _normalizeMetadata(row.metadata);
+  final patches = patchRows.toList()
+    ..sort((a, b) {
+      final cmp = a.orderIndex.compareTo(b.orderIndex);
+      if (cmp != 0) return cmp;
+      return a.baseBundleId.compareTo(b.baseBundleId);
+    });
+
+  final patchArtifacts = patches
+      .map((p) => BundlePatchArtifact(
+            baseBundleId: p.baseBundleId,
+            baseFileHash: p.baseFileHash,
+            patchFileHash: p.patchFileHash,
+            patchStorageUri: p.patchStorageUri,
+          ))
+      .toList();
+
+  final primaryPatch =
+      patchArtifacts.isNotEmpty ? patchArtifacts.first : null;
+
+  return Bundle(
+    id: row.id,
+    channel: row.channel,
+    enabled: row.enabled,
+    shouldForceUpdate: row.shouldForceUpdate,
+    fileHash: row.fileHash,
+    gitCommitHash: row.gitCommitHash,
+    message: row.message,
+    platform: Platform.fromValue(row.platform),
+    targetAppVersion: row.targetAppVersion,
+    fingerprintHash: row.fingerprintHash,
+    storageUri: row.storageUri,
+    metadata:
+        rawMetadata != null ? BundleMetadata.fromJson(rawMetadata) : null,
+    manifestStorageUri: row.manifestStorageUri,
+    manifestFileHash: row.manifestFileHash,
+    assetBaseStorageUri: row.assetBaseStorageUri,
+    patches: patchArtifacts,
+    patchBaseBundleId: primaryPatch?.baseBundleId,
+    patchBaseFileHash: primaryPatch?.baseFileHash,
+    patchFileHash: primaryPatch?.patchFileHash,
+    patchStorageUri: primaryPatch?.patchStorageUri,
+    rolloutCohortCount:
+        row.rolloutCohortCount ?? defaultRolloutCohortCount,
+    targetCohorts: row.targetCohorts,
+  );
+}
+
+/// Map a [Bundle] to a Supabase row for upsert.
+SupabaseBundleRow bundleToRow(Bundle bundle) => SupabaseBundleRow(
+      id: bundle.id,
+      channel: bundle.channel,
+      enabled: bundle.enabled,
+      shouldForceUpdate: bundle.shouldForceUpdate,
+      fileHash: bundle.fileHash,
+      gitCommitHash: bundle.gitCommitHash,
+      message: bundle.message,
+      platform: bundle.platform.value,
+      targetAppVersion: bundle.targetAppVersion,
+      fingerprintHash: bundle.fingerprintHash,
+      storageUri: bundle.storageUri,
+      metadata: stripBundleArtifactMetadata(bundle.metadata?.toJson()),
+      manifestStorageUri: getManifestStorageUri(bundle),
+      manifestFileHash: getManifestFileHash(bundle),
+      assetBaseStorageUri: getAssetBaseStorageUri(bundle),
+      rolloutCohortCount:
+          bundle.rolloutCohortCount ?? defaultRolloutCohortCount,
+      targetCohorts: bundle.targetCohorts,
+    );
+
+/// Map a [Bundle] to its patch rows for upsert.
+List<SupabaseBundlePatchRow> bundleToPatchRows(Bundle bundle) {
+  final patchArtifacts = getBundlePatches(bundle);
+  return [
+    for (var i = 0; i < patchArtifacts.length; i++)
+      SupabaseBundlePatchRow(
+        id: _buildBundlePatchId(
+            bundle.id, patchArtifacts[i].baseBundleId),
+        bundleId: bundle.id,
+        baseBundleId: patchArtifacts[i].baseBundleId,
+        baseFileHash: patchArtifacts[i].baseFileHash,
+        patchFileHash: patchArtifacts[i].patchFileHash,
+        patchStorageUri: patchArtifacts[i].patchStorageUri,
+        orderIndex: i,
+      ),
+  ];
+}