@_nazmiforreal/flutter-ota 0.1.1 → 0.1.3

package/dart-src/plugins/supabase/test/supabase_bundle_mapper_test.dart

@@ -0,0 +1,112 @@
+import 'package:flutter_patcher_core/flutter_patcher_core.dart';
+import 'package:flutter_patcher_supabase/src/supabase_bundle_mapper.dart';
+import 'package:flutter_patcher_supabase/src/types.dart';
+import 'package:test/test.dart';
+
+Bundle _makeBundle({List<BundlePatchArtifact> patches = const []}) => Bundle(
+      id: '018f0000-0000-7000-8000-000000000001',
+      platform: Platform.android,
+      shouldForceUpdate: false,
+      enabled: true,
+      fileHash: 'file-hash-1',
+      gitCommitHash: 'git-1',
+      message: 'hello',
+      channel: 'production',
+      storageUri: 'supabase-storage://updates/bundles/b1.zip',
+      targetAppVersion: '1.0.0',
+      fingerprintHash: 'fp-1',
+      metadata: const BundleMetadata(appVersion: '1.2.3'),
+      manifestStorageUri: 'supabase-storage://updates/manifests/m1.json',
+      manifestFileHash: 'mf-1',
+      assetBaseStorageUri: 'supabase-storage://updates/assets',
+      rolloutCohortCount: 500,
+      targetCohorts: ['team-a'],
+      patches: patches,
+      patchBaseBundleId: patches.isNotEmpty ? patches.first.baseBundleId : null,
+      patchBaseFileHash:
+          patches.isNotEmpty ? patches.first.baseFileHash : null,
+      patchFileHash: patches.isNotEmpty ? patches.first.patchFileHash : null,
+      patchStorageUri:
+          patches.isNotEmpty ? patches.first.patchStorageUri : null,
+    );
+
+void main() {
+  group('bundleToRow / mapRowToBundle round-trip', () {
+    test('preserves scalar fields and stripBundleArtifactMetadata', () {
+      final bundle = _makeBundle();
+      final row = bundleToRow(bundle);
+
+      expect(row.id, bundle.id);
+      expect(row.channel, 'production');
+      expect(row.enabled, true);
+      expect(row.shouldForceUpdate, false);
+      expect(row.fileHash, 'file-hash-1');
+      expect(row.gitCommitHash, 'git-1');
+      expect(row.message, 'hello');
+      expect(row.platform, 'android');
+      expect(row.targetAppVersion, '1.0.0');
+      expect(row.fingerprintHash, 'fp-1');
+      expect(row.storageUri, 'supabase-storage://updates/bundles/b1.zip');
+      expect(row.manifestStorageUri, bundle.manifestStorageUri);
+      expect(row.manifestFileHash, 'mf-1');
+      expect(row.assetBaseStorageUri, bundle.assetBaseStorageUri);
+      expect(row.rolloutCohortCount, 500);
+      expect(row.targetCohorts, ['team-a']);
+      expect(row.metadata, {'app_version': '1.2.3'});
+    });
+
+    test('mapRowToBundle rebuilds derived patch fields', () {
+      final baseBundleId = '018f0000-0000-7000-8000-000000000000';
+      final bundle = _makeBundle(
+        patches: [
+          BundlePatchArtifact(
+            baseBundleId: baseBundleId,
+            baseFileHash: 'base-hash',
+            patchFileHash: 'patch-hash',
+            patchStorageUri: 'supabase-storage://updates/patches/p1.patch',
+          ),
+        ],
+      );
+
+      final row = bundleToRow(bundle);
+      final patchRows = bundleToPatchRows(bundle);
+      expect(patchRows, hasLength(1));
+      expect(patchRows.first.id, '${bundle.id}:$baseBundleId');
+      expect(patchRows.first.bundleId, bundle.id);
+      expect(patchRows.first.baseBundleId, baseBundleId);
+      expect(patchRows.first.orderIndex, 0);
+
+      final back = mapRowToBundle(
+        SupabaseBundleRow.fromJson(row.toJson()),
+        patchRows.map((p) => SupabaseBundlePatchRow.fromJson(p.toJson())).toList(),
+      );
+
+      expect(back.id, bundle.id);
+      expect(back.patches, hasLength(1));
+      expect(back.patchBaseBundleId, baseBundleId);
+      expect(back.patchBaseFileHash, 'base-hash');
+      expect(back.patches!.first.patchFileHash, 'patch-hash');
+      expect(back.patchStorageUri, 'supabase-storage://updates/patches/p1.patch');
+      expect(back.metadata?.appVersion, '1.2.3');
+    });
+
+    test('defaults when row fields are missing', () {
+      final row = SupabaseBundleRow.fromJson({
+        'id': 'id-1',
+        'channel': 'production',
+        'enabled': true,
+        'platform': 'android',
+        'should_force_update': false,
+        'file_hash': 'fh',
+        'storage_uri': 's',
+        'target_app_version': '1.0.0',
+        'metadata': {'app_version': '9.9.9'},
+      });
+      final bundle = mapRowToBundle(row);
+      expect(bundle.rolloutCohortCount, 1000);
+      expect(bundle.targetCohorts, isNull);
+      expect(bundle.metadata?.appVersion, '9.9.9');
+      expect(bundle.manifestStorageUri, isNull);
+    });
+  });
+}

package/dart-src/plugins/supabase/test/supabase_database_test.dart

@@ -0,0 +1,207 @@
+import 'package:flutter_patcher_core/flutter_patcher_core.dart';
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart';
+import 'package:flutter_patcher_supabase/flutter_patcher_supabase.dart';
+import 'package:test/test.dart';
+
+import 'mock_supabase_client.dart';
+
+late Store store;
+late FakeStorageBucket bucket;
+late SupabaseClientLike client;
+
+DatabasePlugin newPlugin() => supabaseDatabase(
+      SupabaseServiceRoleConfig(
+        supabaseUrl: 'https://test.supabase.invalid',
+        supabaseAnonKey: 'test-anon-key',
+        clientFactory: (_, __) => client,
+      ),
+    )();
+
+Bundle _bundle(
+  String id, {
+  bool enabled = true,
+  String? fp,
+  String? message,
+  String channel = 'production',
+}) =>
+    Bundle(
+      id: id,
+      platform: Platform.android,
+      shouldForceUpdate: false,
+      enabled: enabled,
+      fileHash: 'file-$id',
+      gitCommitHash: 'git-$id',
+      message: message ?? 'msg-$id',
+      channel: channel,
+      storageUri: 'supabase-storage://updates/bundles/$id.zip',
+      targetAppVersion: '1.0.0',
+      fingerprintHash: fp,
+      metadata: const BundleMetadata(),
+      manifestStorageUri: 'supabase-storage://updates/manifests/$id.json',
+      manifestFileHash: 'mf-$id',
+      assetBaseStorageUri: 'supabase-storage://updates/assets',
+    );
+
+void main() {
+  setUp(() {
+    store = Store();
+    bucket = FakeStorageBucket();
+    client = createMockSupabaseClient(store: store, bucket: bucket);
+  });
+
+  group('supabaseDatabase bundle methods', () {
+    test('insert + commit + getBundleById round-trips', () async {
+      final plugin = newPlugin();
+      await plugin.appendBundle(_bundle('b1'));
+      await plugin.commitBundle();
+      final got = await plugin.getBundleById('b1');
+      expect(got, isNotNull);
+      expect(got!.id, 'b1');
+      expect(got.fileHash, 'file-b1');
+      expect(got.targetAppVersion, '1.0.0');
+      expect(got.rolloutCohortCount, 1000);
+    });
+
+    test('getBundles filters by where + pagination', () async {
+      final plugin = newPlugin();
+      for (var i = 0; i < 5; i++) {
+        await plugin.appendBundle(_bundle('b$i'));
+      }
+      await plugin.commitBundle();
+
+      final res = await plugin.getBundles(
+        DatabaseBundleQueryOptions(
+          where: DatabaseBundleQueryWhere(
+            channel: 'production',
+            platform: Platform.android,
+          ),
+          limit: 3,
+        ),
+      );
+      expect(res.data, hasLength(3));
+      expect(res.pagination.total, 5);
+    });
+
+    test('getChannels returns distinct channels', () async {
+      final plugin = newPlugin();
+      await plugin.appendBundle(_bundle('b1'));
+      await plugin.appendBundle(
+        _bundle('b2', channel: 'staging'),
+      );
+      await plugin.commitBundle();
+      final channels = await plugin.getChannels();
+      expect(channels, containsAll(['production', 'staging']));
+      expect(channels, hasLength(2));
+    });
+
+    test('updateBundle persists changes', () async {
+      final plugin = newPlugin();
+      await plugin.appendBundle(_bundle('b1'));
+      await plugin.commitBundle();
+      final updated = _bundle('b1', message: 'updated');
+      await plugin.updateBundle('b1', updated.toJson());
+      await plugin.commitBundle();
+      final got = await plugin.getBundleById('b1');
+      expect(got!.message, 'updated');
+    });
+
+    test('deleteBundle removes the row', () async {
+      final plugin = newPlugin();
+      await plugin.appendBundle(_bundle('b1'));
+      await plugin.commitBundle();
+      final got = await plugin.getBundleById('b1');
+      await plugin.deleteBundle(got!);
+      await plugin.commitBundle();
+      expect(await plugin.getBundleById('b1'), isNull);
+    });
+  });
+
+  group('supabaseDatabase getUpdateInfo via RPC', () {
+    test('appVersion strategy returns newer enabled bundle', () async {
+      final plugin = newPlugin();
+      await plugin.appendBundle(
+        _bundle('018f0000-0000-7000-8000-000000000001'),
+      );
+      await plugin.appendBundle(
+        _bundle('018f0000-0000-7000-8000-000000000002'),
+      );
+      await plugin.commitBundle();
+
+      final info = await plugin.getUpdateInfo(
+        AppVersionGetBundlesArgs(
+          appVersion: '1.0.0',
+          bundleId: '018f0000-0000-7000-8000-000000000001',
+          channel: 'production',
+          minBundleId: nilUuid,
+          platform: Platform.android,
+        ),
+      );
+      expect(info, isNotNull);
+      expect(info!.id, '018f0000-0000-7000-8000-000000000002');
+      expect(info.status, UpdateStatus.update);
+    });
+
+    test('fingerprint strategy returns matching bundle', () async {
+      final plugin = newPlugin();
+      await plugin.appendBundle(
+        _bundle(
+          '018f0000-0000-7000-8000-000000000001',
+          fp: 'fp-current',
+        ),
+      );
+      await plugin.appendBundle(
+        _bundle(
+          '018f0000-0000-7000-8000-000000000002',
+          fp: 'fp-target',
+        ),
+      );
+      await plugin.commitBundle();
+
+      final info = await plugin.getUpdateInfo(
+        FingerprintGetBundlesArgs(
+          fingerprintHash: 'fp-target',
+          bundleId: '018f0000-0000-7000-8000-000000000001',
+          channel: 'production',
+          minBundleId: nilUuid,
+          platform: Platform.android,
+        ),
+      );
+      expect(info, isNotNull);
+      expect(info!.id, '018f0000-0000-7000-8000-000000000002');
+    });
+
+    test('returns rollback when no compatible newer bundle exists', () async {
+      final plugin = newPlugin();
+      await plugin.appendBundle(
+        _bundle('018f0000-0000-7000-8000-000000000001'),
+      );
+      await plugin.commitBundle();
+
+      final info = await plugin.getUpdateInfo(
+        AppVersionGetBundlesArgs(
+          appVersion: '9.9.9',
+          bundleId: '018f0000-0000-7000-8000-000000000001',
+          channel: 'production',
+          minBundleId: nilUuid,
+          platform: Platform.android,
+        ),
+      );
+      expect(info, isNotNull);
+      expect(info!.status, UpdateStatus.rollback);
+    });
+
+    test('returns null for an init bundle with no candidates', () async {
+      final plugin = newPlugin();
+      final info = await plugin.getUpdateInfo(
+        AppVersionGetBundlesArgs(
+          appVersion: '9.9.9',
+          bundleId: nilUuid,
+          channel: 'production',
+          minBundleId: nilUuid,
+          platform: Platform.android,
+        ),
+      );
+      expect(info, isNull);
+    });
+  });
+}

package/dart-src/plugins/supabase/test/supabase_storage_test.dart

@@ -0,0 +1,175 @@
+import 'dart:io' as io;
+
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart';
+import 'package:flutter_patcher_supabase/flutter_patcher_supabase.dart';
+import 'package:test/test.dart';
+
+import 'mock_supabase_client.dart';
+
+late Store store;
+late FakeStorageBucket bucket;
+late SupabaseClientLike client;
+late StoragePlugin storage;
+late NodeStorageProfile node;
+late RuntimeStorageProfile runtime;
+
+void main() {
+  setUp(() {
+    store = Store();
+    bucket = FakeStorageBucket();
+    client = createMockSupabaseClient(store: store, bucket: bucket);
+    storage = supabaseStorage(
+      SupabaseStorageConfig(
+        bucketName: 'updates',
+        supabaseUrl: 'https://example.supabase.co',
+        supabaseAnonKey: 'anon-key',
+        clientFactory: (_, __) => client,
+      ),
+    );
+    node = storage.profiles.node!;
+    runtime = storage.profiles.runtime!;
+  });
+
+  group('supabaseStorage node.exists', () {
+    test('returns true for existing, signable objects', () async {
+      bucket.existsData = true;
+      bucket.signedUrlData = 'https://example.supabase.co/signed-url';
+      final result = await node.exists(
+        'supabase-storage://updates/assets/sha256/fi/file-hash.png',
+      );
+      expect(result, isTrue);
+      expect(bucket.existsCalls, ['assets/sha256/fi/file-hash.png']);
+      expect(bucket.createSignedUrlCalls, ['assets/sha256/fi/file-hash.png']);
+    });
+
+    test('returns false when object is missing', () async {
+      bucket.existsData = false;
+      bucket.existsError = 'Object not found';
+      final result = await node.exists(
+        'supabase-storage://updates/assets/sha256/fi/file-hash.png',
+      );
+      expect(result, isFalse);
+      expect(bucket.createSignedUrlCalls, isEmpty);
+    });
+
+    test('rejects existing objects that are not signable', () async {
+      bucket.existsData = true;
+      bucket.signedUrlError = 'Object not found';
+      await expectLater(
+        node.exists(
+          'supabase-storage://updates/assets/sha256/fi/file-hash.png',
+        ),
+        throwsA(
+          isA<StateError>().having(
+            (e) => e.message,
+            'message',
+            contains(
+              'Failed to generate download URL for '
+              '"assets/sha256/fi/file-hash.png": Object not found',
+            ),
+          ),
+        ),
+      );
+      expect(bucket.createSignedUrlCalls, hasLength(1));
+    });
+
+    test('rejects a different bucket', () async {
+      await expectLater(
+        node.exists(
+          'supabase-storage://other/assets/sha256/fi/file-hash.png',
+        ),
+        throwsA(
+          isA<StateError>().having(
+            (e) => e.message,
+            'message',
+            contains('Bucket name mismatch: expected "updates"'),
+          ),
+        ),
+      );
+      expect(bucket.existsCalls, isEmpty);
+    });
+  });
+
+  group('supabaseStorage runtime.getDownloadUrl', () {
+    test('batches concurrent signed URL requests', () async {
+      final paths = List.generate(
+        20,
+        (i) => 'assets/sha256/file-$i.png',
+      );
+      final results = await Future.wait(
+        paths.map((p) => runtime.getDownloadUrl('supabase-storage://updates/$p')),
+      );
+      expect(
+        results,
+        paths
+            .map((p) => {'fileUrl': 'https://example.supabase.co/3600/$p'})
+            .toList(),
+      );
+      expect(bucket.createSignedUrlsCalls, hasLength(1));
+      expect(bucket.createSignedUrlsCalls.first, paths);
+    });
+
+    test('surfaces non-missing signed URL errors', () async {
+      bucket.signedUrlError = 'Storage API failed';
+      await expectLater(
+        runtime.getDownloadUrl(
+          'supabase-storage://updates/assets/sha256/fi/file-hash.png',
+        ),
+        throwsA(
+          isA<StateError>().having(
+            (e) => e.message,
+            'message',
+            contains(
+              'Failed to generate download URL for '
+              '"assets/sha256/fi/file-hash.png": Storage API failed',
+            ),
+          ),
+        ),
+      );
+      expect(bucket.createSignedUrlsCalls, hasLength(1));
+    });
+
+    test('decodes percent-encoded object keys before signing and removing',
+        () async {
+      const uri = 'supabase-storage://updates/'
+          'assets/bootsplash/logo-ios%402x.png';
+      final url = await runtime.getDownloadUrl(uri);
+      expect(
+        url,
+        {
+          'fileUrl': 'https://example.supabase.co/3600/'
+              'assets/bootsplash/logo-ios@2x.png'
+        },
+      );
+      expect(
+        bucket.createSignedUrlsCalls.first,
+        ['assets/bootsplash/logo-ios@2x.png'],
+      );
+
+      await node.delete(uri);
+      expect(
+        bucket.removeCalls.first,
+        ['assets/bootsplash/logo-ios@2x.png'],
+      );
+    });
+  });
+
+  group('supabaseStorage node.upload', () {
+    test('returns storageUri for a signable upload', () async {
+      final dir = await io.Directory.systemTemp.createTemp('hu-supabase-');
+      final uploadPath = '${dir.path}/bundle.zip';
+      await io.File(uploadPath).writeAsString('bundle');
+      bucket.uploadData = {'fullPath': 'updates/bundles/bundle.zip'};
+
+      final result = await node.upload('bundles', uploadPath);
+      expect(
+        result,
+        {'storageUri': 'supabase-storage://updates/bundles/bundle.zip'},
+      );
+      expect(bucket.uploadCalls, ['bundles/bundle.zip']);
+      expect(bucket.createSignedUrlCalls, ['bundles/bundle.zip']);
+
+      await dir.delete(recursive: true);
+    });
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@_nazmiforreal/flutter-ota",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Command-line interface for flutter_patcher — an OTA code-push tool for Flutter, hot-updater compatible.",
   "bin": {
     "flutter-patcher": "./bin/flutter-patcher.js"

package/scripts/postinstall.js

@@ -6,6 +6,11 @@
 // `flutter-patcher-<os>-<arch>` binary ships in `bin/`, use it. Otherwise, when
 // the Dart SDK is present, compile one from the bundled Dart source so the
 // package works on architectures we did not prebuild (e.g. arm64).
+//
+// We explicitly run `dart pub get` first so dependency resolution is reliable
+// (a stale/locked tree would otherwise fail to fetch packages). If compilation
+// cannot be performed we warn (and exit 0) rather than failing the whole npm
+// install — the launcher prints a clear "how to build" message at runtime.
 
 const { spawnSync } = require('child_process');
 const fs = require('fs');
@@ -27,6 +32,7 @@ const ext = process.platform === 'win32' ? '.exe' : '';
 const pkgDir = path.join(__dirname, '..');
 const binDir = path.join(pkgDir, 'bin');
 const target = path.join(binDir, `flutter-patcher-${platformName}-${archName}${ext}`);
+const cliDir = path.join(pkgDir, 'dart-src', 'packages', 'cli-tools');
 
 if (fs.existsSync(target)) {
   console.log(`flutter-patcher: prebuilt binary present (${platformName}-${archName}), skipping build.`);
@@ -43,20 +49,33 @@ if (dartCheck.status !== 0) {
   process.exit(0);
 }
 
-const sourceEntry = path.join(
-  pkgDir, 'dart-src', 'packages', 'cli-tools', 'bin', 'flutter_patcher.dart',
-);
-if (!fs.existsSync(sourceEntry)) {
+if (!fs.existsSync(path.join(cliDir, 'pubspec.yaml'))) {
   console.warn('flutter-patcher: bundled Dart source not found; skipping build.');
   process.exit(0);
 }
 
-// Compile from within the cli-tools package dir so its pubspec (and local path
-// dependencies) resolve correctly.
+console.log('flutter-patcher: resolving Dart dependencies (dart pub get)...');
+const getRes = spawnSync('dart', ['pub', 'get'], { stdio: 'inherit', cwd: cliDir });
+if (getRes.status !== 0) {
+  console.warn(
+    'flutter-patcher: `dart pub get` failed (check your network / Dart version). ' +
+      `To build manually:\n  cd ${cliDir} && dart compile exe bin/flutter_patcher.dart ` +
+      `-o ${target}`,
+  );
+  process.exit(0);
+}
+
 console.log('flutter-patcher: building native binary with `dart compile exe`...');
 const res = spawnSync(
   'dart',
   ['compile', 'exe', 'bin/flutter_patcher.dart', '-o', target],
-  { stdio: 'inherit', cwd: path.dirname(path.dirname(sourceEntry)) },
+  { stdio: 'inherit', cwd: cliDir },
 );
-process.exit(res.status == null ? 1 : res.status);
+if (res.status !== 0) {
+  console.warn(
+    'flutter-patcher: build failed. To build manually:\n  cd ' +
+      `${cliDir} && dart compile exe bin/flutter_patcher.dart -o ${target}`,
+  );
+  process.exit(0);
+}
+console.log(`flutter-patcher: built ${target}`);

package/scripts/vendor.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# Regenerate the vendored Dart source under dart-src/ from the monorepo so the
+# npm package can `dart compile exe` on any architecture (e.g. arm64).
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/../../.." && pwd)"
+DST="$(cd "$(dirname "$0")/.." && pwd)/dart-src"
+SRC="$ROOT"
+
+echo "Vendoring Dart source from $SRC into $DST"
+
+rm -rf "$DST"
+mkdir -p "$DST/packages" "$DST/plugins"
+
+for p in packages/core packages/cli-tools; do
+  cp -R "$SRC/$p" "$DST/$p"
+done
+for p in plugins/cloudflare plugins/plugin-core plugins/postgres plugins/aws plugins/standalone plugins/supabase; do
+  cp -R "$SRC/$p" "$DST/$p"
+done
+
+# Drop tooling/lock artifacts so `dart pub get` resolves fresh on install.
+find "$DST" -name pubspec.lock -delete
+find "$DST" -name .dart_tool -type d -prune -exec rm -rf {} +
+find "$DST" -name build -type d -prune -exec rm -rf {} +
+find "$DST" -name .git -type d -prune -exec rm -rf {} +
+find "$DST" -name coverage -type d -prune -exec rm -rf {} +
+
+echo "Done. dart-src size: $(du -sh "$DST" | cut -f1)"