@_nazmiforreal/flutter-ota 0.1.0 → 0.1.2

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

@@ -0,0 +1,298 @@
+/// Faithful port of hot-updater `plugins/supabase/src/supabaseStorage.ts`.
+library;
+
+import 'dart:io' as io;
+
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart';
+
+import 'supabase_client_adapter.dart';
+import 'supabase_client_http.dart';
+import 'supabase_config.dart';
+import 'supabase_signed_url_batcher.dart';
+
+/// Parse a `supabase-storage://` URI into bucket + key.
+ParsedStorageUri parseSupabaseStorageUri(String storageUri) =>
+    parseStorageUri(storageUri, 'supabase-storage');
+
+/// Configuration for the Supabase storage plugin.
+class SupabaseStorageConfig extends SupabaseServiceRoleConfig {
+  final String bucketName;
+
+  /// Base path where bundles are stored in the bucket.
+  final String? basePath;
+
+  const SupabaseStorageConfig({
+    required super.supabaseUrl,
+    super.supabaseServiceRoleKey,
+    super.supabaseAnonKey,
+    super.clientFactory,
+    required this.bucketName,
+    this.basePath,
+  });
+}
+
+String _getErrorMessage(Object? error) {
+  if (error is Error) return error.toString();
+  if (error is Exception) return error.toString();
+  if (error is Map && error['message'] is String) {
+    return error['message'] as String;
+  }
+  return error.toString();
+}
+
+Future<String> _createSignedUrlOrThrow({
+  required SupabaseStorageBucketLike bucket,
+  required String key,
+  required int expiresIn,
+}) async {
+  late Object? error;
+  String? signedUrl;
+  try {
+    final response = await bucket.createSignedUrl(key, expiresIn);
+    signedUrl = response.signedUrl;
+    error = response.error;
+  } catch (thrown) {
+    error = thrown;
+  }
+
+  if (error == null && signedUrl != null) {
+    return signedUrl;
+  }
+
+  throw StateError(
+    'Failed to generate download URL for "$key": '
+    '${_getErrorMessage(error ?? StateError("missing signed URL"))}',
+  );
+}
+
+Future<void> _verifyObjectCanBeSignedForRuntime({
+  required SupabaseStorageBucketLike bucket,
+  required String key,
+}) async {
+  await _createSignedUrlOrThrow(
+    bucket: bucket,
+    key: key,
+    expiresIn: 3600,
+  );
+}
+
+/// Supabase-backed universal (node + runtime) storage plugin.
+final supabaseStorage = createUniversalStoragePlugin<SupabaseStorageConfig>(
+  name: 'supabaseStorage',
+  supportedProtocol: 'supabase-storage',
+  factory: (config) {
+    final supabase = config.clientFactory != null
+        ? config.clientFactory!(config.supabaseUrl, config.resolveKey())
+        : createSupabaseHttpClient(config.supabaseUrl, config.resolveKey());
+
+    final bucket = supabase.storage.from(config.bucketName);
+    final getStorageKey = createStorageKeyBuilder(config.basePath);
+    final resolveSignedUrl = createSupabaseSignedUrlBatcher(
+      createSignedUrls: (bucketName, keys, expiresIn) =>
+          supabase.storage.from(bucketName).createSignedUrls(keys, expiresIn),
+      expiresIn: 3600,
+      formatObjectPath: (bucketName, key) => key,
+    );
+
+    return (
+      node: NodeStorageProfileImpl(
+        bucket: bucket,
+        getStorageKey: getStorageKey,
+        bucketName: config.bucketName,
+        verifySigned: _verifyObjectCanBeSignedForRuntime,
+        createSignedUrlOrThrow: _createSignedUrlOrThrow,
+      ),
+      runtime: RuntimeStorageProfileImpl(
+        bucket: bucket,
+        resolveSignedUrl: resolveSignedUrl,
+        bucketName: config.bucketName,
+      ),
+    );
+  },
+);
+
+class NodeStorageProfileImpl implements NodeStorageProfile {
+  NodeStorageProfileImpl({
+    required this.bucket,
+    required this.getStorageKey,
+    required this.bucketName,
+    required this.verifySigned,
+    required this.createSignedUrlOrThrow,
+  });
+
+  final SupabaseStorageBucketLike bucket;
+  final String Function(String, [String, String, String]) getStorageKey;
+  final String bucketName;
+  final Future<void> Function({
+    required SupabaseStorageBucketLike bucket,
+    required String key,
+  }) verifySigned;
+  final Future<String> Function({
+    required SupabaseStorageBucketLike bucket,
+    required String key,
+    required int expiresIn,
+  }) createSignedUrlOrThrow;
+
+  @override
+  Future<Map<String, String>> upload(String key, String filePath) async {
+    final body = await io.File(filePath).readAsBytes();
+    final contentType = getContentType(filePath);
+    final filename = filePath.split(io.Platform.pathSeparator).last;
+    final storageKey = getStorageKey(key, filename);
+
+    final upload = await bucket.upload(
+      storageKey,
+      body,
+      contentType: contentType,
+      cacheControl: 'max-age=31536000',
+    );
+    if (upload.error != null) {
+      throw StateError(_getErrorMessage(upload.error));
+    }
+
+    await verifySigned(bucket: bucket, key: storageKey);
+    final fullPath = upload.data is Map
+        ? (upload.data as Map)['fullPath'] as String?
+        : null;
+    return {
+      'storageUri': 'supabase-storage://${fullPath ?? storageKey}',
+    };
+  }
+
+  @override
+  Future<bool> exists(String storageUri) async {
+    final parsed = parseSupabaseStorageUri(storageUri);
+    if (parsed.bucket != bucketName) {
+      throw StateError(
+        'Bucket name mismatch: expected "$bucketName", but found '
+        '"${parsed.bucket}".',
+      );
+    }
+    final res = await bucket.exists(parsed.key);
+    if (res.data == false) return false;
+    if (res.error != null) {
+      throw StateError(_getErrorMessage(res.error));
+    }
+    await verifySigned(bucket: bucket, key: parsed.key);
+    return res.data as bool;
+  }
+
+  @override
+  Future<void> delete(String storageUri) async {
+    final parsed = parseSupabaseStorageUri(storageUri);
+    if (parsed.bucket != bucketName) {
+      throw StateError(
+        'Bucket name mismatch: expected "$bucketName", but found '
+        '"${parsed.bucket}".',
+      );
+    }
+    final res = await bucket.remove([parsed.key]);
+    if (res.error != null) {
+      final msg = res.message ?? _getErrorMessage(res.error);
+      if (msg.contains('not found')) {
+        throw StateError('Bundle not found');
+      }
+      throw StateError('Failed to delete bundle: $msg');
+    }
+  }
+
+  @override
+  Future<void> downloadFile(String storageUri, String filePath) async {
+    final parsed = parseSupabaseStorageUri(storageUri);
+    if (parsed.bucket != bucketName) {
+      throw StateError(
+        'Bucket name mismatch: expected "$bucketName", but found '
+        '"${parsed.bucket}".',
+      );
+    }
+    final res = await bucket.download(parsed.key);
+    if (res.error != null) {
+      throw StateError('Failed to download bundle: ${res.message}');
+    }
+    if (res.data == null) {
+      throw StateError('Failed to download bundle');
+    }
+    final dir = filePath.substring(0, filePath.lastIndexOf(io.Platform.pathSeparator));
+    await io.Directory(dir).create(recursive: true);
+    await io.File(filePath).writeAsBytes(res.data!);
+  }
+
+  @override
+  Future<List<StorageObject>> listObjects([String? prefix]) async {
+    final res = await bucket.list(prefix);
+    if (res.error != null) {
+      throw StateError(
+        'Failed to list objects: ${_getErrorMessage(res.error)}',
+      );
+    }
+    final data = res.data ?? const <SupabaseStorageObject>[];
+    return data
+        .map(
+          (o) => StorageObject(
+            key: o.key,
+            storageUri: 'supabase-storage://$bucketName/${o.key}',
+            size: o.size,
+            lastModifiedAt: o.lastModifiedAt != null
+                ? DateTime.tryParse(o.lastModifiedAt!)
+                : null,
+          ),
+        )
+        .toList();
+  }
+
+  @override
+  Future<void> deleteObjects(List<String> keys) async {
+    if (keys.isEmpty) return;
+    final res = await bucket.remove(keys);
+    if (res.error != null) {
+      final msg = res.message ?? _getErrorMessage(res.error);
+      if (!msg.contains('not found')) {
+        throw StateError('Failed to delete objects: $msg');
+      }
+    }
+  }
+}
+
+class RuntimeStorageProfileImpl implements RuntimeStorageProfile {
+  RuntimeStorageProfileImpl({
+    required this.bucket,
+    required this.resolveSignedUrl,
+    required this.bucketName,
+  });
+
+  final SupabaseStorageBucketLike bucket;
+  final ResolveSignedUrl resolveSignedUrl;
+  final String bucketName;
+
+  @override
+  Future<String?> readText(String storageUri) async {
+    final parsed = parseSupabaseStorageUri(storageUri);
+    if (parsed.bucket != bucketName) {
+      throw StateError(
+        'Bucket name mismatch: expected "$bucketName", but found '
+        '"${parsed.bucket}".',
+      );
+    }
+    final res = await bucket.download(parsed.key);
+    if (res.error != null) {
+      final msg = res.message ?? _getErrorMessage(res.error);
+      if (msg.contains('not found')) return null;
+      throw StateError('Failed to read storage text: $msg');
+    }
+    if (res.data == null) return null;
+    return String.fromCharCodes(res.data!);
+  }
+
+  @override
+  Future<Map<String, String>> getDownloadUrl(String storageUri) async {
+    final parsed = parseSupabaseStorageUri(storageUri);
+    if (parsed.bucket != bucketName) {
+      throw StateError(
+        'Bucket name mismatch: expected "$bucketName", but found '
+        '"${parsed.bucket}".',
+      );
+    }
+    final signedUrl = await resolveSignedUrl(bucketName, parsed.key);
+    return {'fileUrl': signedUrl};
+  }
+}

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

@@ -0,0 +1,130 @@
+/// Faithful port of hot-updater `plugins/supabase/src/types.ts`.
+library;
+
+/// Row type from Supabase `bundles` table.
+class SupabaseBundleRow {
+  final String id;
+  final String channel;
+  final bool enabled;
+  final bool shouldForceUpdate;
+  final String fileHash;
+  final String? gitCommitHash;
+  final String? message;
+  final String platform;
+  final String? targetAppVersion;
+  final String? fingerprintHash;
+  final String storageUri;
+  final Map<String, Object?>? metadata;
+  final String? manifestStorageUri;
+  final String? manifestFileHash;
+  final String? assetBaseStorageUri;
+  final int? rolloutCohortCount;
+  final List<String>? targetCohorts;
+
+  const SupabaseBundleRow({
+    required this.id,
+    required this.channel,
+    required this.enabled,
+    required this.shouldForceUpdate,
+    required this.fileHash,
+    this.gitCommitHash,
+    this.message,
+    required this.platform,
+    this.targetAppVersion,
+    this.fingerprintHash,
+    required this.storageUri,
+    this.metadata,
+    this.manifestStorageUri,
+    this.manifestFileHash,
+    this.assetBaseStorageUri,
+    this.rolloutCohortCount,
+    this.targetCohorts,
+  });
+
+  factory SupabaseBundleRow.fromJson(Map<String, dynamic> j) =>
+      SupabaseBundleRow(
+        id: j['id'] as String,
+        channel: j['channel'] as String,
+        enabled: j['enabled'] as bool,
+        shouldForceUpdate: j['should_force_update'] as bool,
+        fileHash: j['file_hash'] as String,
+        gitCommitHash: j['git_commit_hash'] as String?,
+        message: j['message'] as String?,
+        platform: j['platform'] as String,
+        targetAppVersion: j['target_app_version'] as String?,
+        fingerprintHash: j['fingerprint_hash'] as String?,
+        storageUri: j['storage_uri'] as String,
+        metadata: j['metadata'] is Map
+            ? (j['metadata'] as Map).cast<String, Object?>()
+            : null,
+        manifestStorageUri: j['manifest_storage_uri'] as String?,
+        manifestFileHash: j['manifest_file_hash'] as String?,
+        assetBaseStorageUri: j['asset_base_storage_uri'] as String?,
+        rolloutCohortCount: j['rollout_cohort_count'] as int?,
+        targetCohorts: (j['target_cohorts'] as List?)
+            ?.map((e) => e as String)
+            .toList(),
+      );
+
+  Map<String, dynamic> toJson() => {
+        'id': id,
+        'channel': channel,
+        'enabled': enabled,
+        'should_force_update': shouldForceUpdate,
+        'file_hash': fileHash,
+        'git_commit_hash': gitCommitHash,
+        'message': message,
+        'platform': platform,
+        'target_app_version': targetAppVersion,
+        'fingerprint_hash': fingerprintHash,
+        'storage_uri': storageUri,
+        'metadata': metadata,
+        'manifest_storage_uri': manifestStorageUri,
+        'manifest_file_hash': manifestFileHash,
+        'asset_base_storage_uri': assetBaseStorageUri,
+        'rollout_cohort_count': rolloutCohortCount,
+        'target_cohorts': targetCohorts,
+      };
+}
+
+/// Row type from Supabase `bundle_patches` table.
+class SupabaseBundlePatchRow {
+  final String id;
+  final String bundleId;
+  final String baseBundleId;
+  final String baseFileHash;
+  final String patchFileHash;
+  final String patchStorageUri;
+  final int orderIndex;
+
+  const SupabaseBundlePatchRow({
+    required this.id,
+    required this.bundleId,
+    required this.baseBundleId,
+    required this.baseFileHash,
+    required this.patchFileHash,
+    required this.patchStorageUri,
+    required this.orderIndex,
+  });
+
+  factory SupabaseBundlePatchRow.fromJson(Map<String, dynamic> j) =>
+      SupabaseBundlePatchRow(
+        id: j['id'] as String,
+        bundleId: j['bundle_id'] as String,
+        baseBundleId: j['base_bundle_id'] as String,
+        baseFileHash: j['base_file_hash'] as String,
+        patchFileHash: j['patch_file_hash'] as String,
+        patchStorageUri: j['patch_storage_uri'] as String,
+        orderIndex: j['order_index'] as int,
+      );
+
+  Map<String, dynamic> toJson() => {
+        'id': id,
+        'bundle_id': bundleId,
+        'base_bundle_id': baseBundleId,
+        'base_file_hash': baseFileHash,
+        'patch_file_hash': patchFileHash,
+        'patch_storage_uri': patchStorageUri,
+        'order_index': orderIndex,
+      };
+}

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

@@ -0,0 +1,19 @@
+name: flutter_patcher_supabase
+description: Supabase plugin for flutter_patcher — database + storage backends.
+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
+  supabase: ^2.14.0
+
+dev_dependencies:
+  test: ^1.25.0
+  lints: ^4.0.0

package/dart-src/plugins/supabase/supabase/edge-functions/index.ts

@@ -0,0 +1,44 @@
+import "jsr:@supabase/functions-js/edge-runtime.d.ts";
+import { createHotUpdater } from "@hot-updater/server";
+import {
+  supabaseEdgeFunctionDatabase,
+  supabaseEdgeFunctionStorage,
+} from "@hot-updater/supabase";
+import { Hono } from "hono";
+
+declare global {
+  var HotUpdater: {
+    FUNCTION_NAME: string;
+  };
+}
+
+const functionName = HotUpdater.FUNCTION_NAME;
+const supabaseUrl = Deno.env.get("SUPABASE_URL") ?? "";
+const supabaseServiceRoleKey = Deno.env.get("SUPABASE_SERVICE_ROLE_KEY") ?? "";
+const functionBasePath = `/${functionName}`;
+const hotUpdaterBasePath = "/";
+
+const hotUpdater = createHotUpdater({
+  database: supabaseEdgeFunctionDatabase({
+    supabaseUrl,
+    supabaseServiceRoleKey,
+  }),
+  storages: [
+    supabaseEdgeFunctionStorage({
+      supabaseUrl,
+      supabaseServiceRoleKey,
+    }),
+  ],
+  basePath: hotUpdaterBasePath,
+  routes: {
+    updateCheck: true,
+    bundles: false,
+  },
+});
+
+const app = new Hono().basePath(functionBasePath);
+
+app.get("/ping", (c) => c.text("pong"));
+app.mount(hotUpdaterBasePath, hotUpdater.handler);
+
+Deno.serve(app.fetch);