@_nazmiforreal/flutter-ota 0.1.12 → 0.1.13

package/dart-src/packages/cli-tools/test/mocks/mock_postgres_client.dart

@@ -54,10 +54,7 @@ class MockPostgresClient implements PostgresClientLike {
   @override
   Future<void> close() async {}
 
-  List<Map<String, dynamic>> _handle(
-    String sql,
-    Map<String, dynamic> params,
-  ) {
+  List<Map<String, dynamic>> _handle(String sql, Map<String, dynamic> params) {
     if (sql.contains('get_target_app_version_list')) {
       return _targetAppVersionList(params);
     }
@@ -106,13 +103,17 @@ class MockPostgresClient implements PostgresClientLike {
       store.storageObjects[key] = data is List<int>
           ? data
           : data is Uint8List
-              ? data
-              : <int>[];
+          ? data
+          : <int>[];
       return [];
     }
     if (sql.contains('SELECT 1 FROM flutter_ota_kit_storage')) {
       final key = params['@key'] as String;
-      return store.storageObjects.containsKey(key) ? [{'1': 1}] : [];
+      return store.storageObjects.containsKey(key)
+          ? [
+              {'1': 1},
+            ]
+          : [];
     }
     if (sql.contains('DELETE FROM flutter_ota_kit_storage')) {
       final key = params['@key'] as String;
@@ -131,10 +132,7 @@ class MockPostgresClient implements PostgresClientLike {
       final prefix = (params['@prefix'] as String?) ?? '';
       return store.storageObjects.keys
           .where((k) => k.startsWith(prefix))
-          .map((k) => {
-                'key': k,
-                'size': store.storageObjects[k]!.length,
-              })
+          .map((k) => {'key': k, 'size': store.storageObjects[k]!.length})
           .toList();
     }
     return [];
@@ -176,7 +174,8 @@ class MockPostgresClient implements PostgresClientLike {
     var rows = _filterBundles(sql, params);
 
     if (sql.contains('ORDER BY id asc')) {
-      rows = rows.toList()..sort((a, b) => (a['id'] as String).compareTo(b['id'] as String));
+      rows = rows.toList()
+        ..sort((a, b) => (a['id'] as String).compareTo(b['id'] as String));
     } else {
       rows = rows.toList()
         ..sort((a, b) => (b['id'] as String).compareTo(a['id'] as String));
@@ -200,13 +199,18 @@ class MockPostgresClient implements PostgresClientLike {
   }
 
   List<Map<String, dynamic>> _channels() {
-    final channels = store.bundleRows.map((r) => r['channel'] as String).toSet().toList();
+    final channels = store.bundleRows
+        .map((r) => r['channel'] as String)
+        .toSet()
+        .toList();
     return channels.map((c) => {'channel': c}).toList();
   }
 
   List<Map<String, dynamic>> _patchesForIds(Map<String, dynamic> params) {
     final ids = (params['bundle_ids'] as List).cast<String>();
-    return store.bundlePatchRows.where((p) => ids.contains(p['bundle_id'])).toList();
+    return store.bundlePatchRows
+        .where((p) => ids.contains(p['bundle_id']))
+        .toList();
   }
 
   void _upsertBundle(Map<String, dynamic> params) {
@@ -223,7 +227,9 @@ class MockPostgresClient implements PostgresClientLike {
   void _upsertPatch(Map<String, dynamic> params) {
     final row = <String, dynamic>{};
     params.forEach((k, v) => row[k] = v);
-    final existing = store.bundlePatchRows.indexWhere((r) => r['id'] == row['id']);
+    final existing = store.bundlePatchRows.indexWhere(
+      (r) => r['id'] == row['id'],
+    );
     if (existing >= 0) {
       store.bundlePatchRows[existing] = row;
     } else {
@@ -248,14 +254,24 @@ class MockPostgresClient implements PostgresClientLike {
     final existed = store.bundleRows.any((r) => r['id'] == id);
     store.bundleRows.removeWhere((r) => r['id'] == id);
     store.bundlePatchRows.removeWhere((p) => p['bundle_id'] == id);
-    return existed ? [{'id': id}] : [];
+    return existed
+        ? [
+            {'id': id},
+          ]
+        : [];
   }
 
-  List<Map<String, dynamic>> _targetAppVersionList(Map<String, dynamic> params) {
+  List<Map<String, dynamic>> _targetAppVersionList(
+    Map<String, dynamic> params,
+  ) {
     final platform = params['app_platform'];
     final min = params['min_bundle_id'] as String? ?? '';
     final versions = store.bundleRows
-        .where((r) => r['platform'] == platform && (r['id'] as String).compareTo(min) >= 0)
+        .where(
+          (r) =>
+              r['platform'] == platform &&
+              (r['id'] as String).compareTo(min) >= 0,
+        )
         .map((r) => r['target_app_version'])
         .where((v) => v != null)
         .toSet()
@@ -272,44 +288,53 @@ class MockPostgresClient implements PostgresClientLike {
     return matches.isEmpty ? null : matches.first;
   }
 
-  List<Map<String, dynamic>> _updateInfoByAppVersion(Map<String, dynamic> params) {
+  List<Map<String, dynamic>> _updateInfoByAppVersion(
+    Map<String, dynamic> params,
+  ) {
     final platform = params['app_platform'];
     final channel = params['target_channel'];
     final min = params['min_bundle_id'] as String? ?? '';
-    final list = (params['target_app_version_list'] as List?)?.cast<String>() ?? [];
-    final row = _newestMatch((r) =>
-        r['platform'] == platform &&
-        r['enabled'] == true &&
-        r['channel'] == channel &&
-        (r['id'] as String).compareTo(min) >= 0 &&
-        list.contains(r['target_app_version']));
+    final list =
+        (params['target_app_version_list'] as List?)?.cast<String>() ?? [];
+    final row = _newestMatch(
+      (r) =>
+          r['platform'] == platform &&
+          r['enabled'] == true &&
+          r['channel'] == channel &&
+          (r['id'] as String).compareTo(min) >= 0 &&
+          list.contains(r['target_app_version']),
+    );
     if (row == null) return [];
     return [_infoRow(row)];
   }
 
-  List<Map<String, dynamic>> _updateInfoByFingerprint(Map<String, dynamic> params) {
+  List<Map<String, dynamic>> _updateInfoByFingerprint(
+    Map<String, dynamic> params,
+  ) {
     final platform = params['app_platform'];
     final channel = params['target_channel'];
     final min = params['min_bundle_id'] as String? ?? '';
     final fp = params['target_fingerprint_hash'];
-    final row = _newestMatch((r) =>
-        r['platform'] == platform &&
-        r['enabled'] == true &&
-        r['channel'] == channel &&
-        (r['id'] as String).compareTo(min) >= 0 &&
-        r['fingerprint_hash'] == fp);
+    final row = _newestMatch(
+      (r) =>
+          r['platform'] == platform &&
+          r['enabled'] == true &&
+          r['channel'] == channel &&
+          (r['id'] as String).compareTo(min) >= 0 &&
+          r['fingerprint_hash'] == fp,
+    );
     if (row == null) return [];
     return [_infoRow(row)];
   }
 
   Map<String, dynamic> _infoRow(Map<String, dynamic> row) => {
-        'id': row['id'],
-        'should_force_update': row['should_force_update'],
-        'message': row['message'],
-        'status': 'UPDATE',
-        'storage_uri': row['storage_uri'],
-        'file_hash': row['file_hash'],
-      };
+    'id': row['id'],
+    'should_force_update': row['should_force_update'],
+    'message': row['message'],
+    'status': 'UPDATE',
+    'storage_uri': row['storage_uri'],
+    'file_hash': row['file_hash'],
+  };
 }
 
 class _TxClient implements PostgresClientLike {
@@ -321,8 +346,7 @@ class _TxClient implements PostgresClientLike {
   Future<List<Map<String, dynamic>>> execute(
     String sql,
     Map<String, dynamic> parameters,
-  ) =>
-      _parent.execute(sql, parameters);
+  ) => _parent.execute(sql, parameters);
 
   @override
   Future<T> runTx<T>(Future<T> Function(PostgresClientLike tx) fn) =>
@@ -334,10 +358,10 @@ class _TxClient implements PostgresClientLike {
 
 /// Build a [PostgresConfig] wired to [MockPostgresClient].
 PostgresConfig mockPostgresConfig(Store store) => PostgresConfig(
-      host: 'mock',
-      database: 'mock',
-      clientFactory: (_) => MockPostgresClient(store),
-    );
+  host: 'mock',
+  database: 'mock',
+  clientFactory: (_) => MockPostgresClient(store),
+);
 
 /// Create a [DatabasePlugin] backed by the mock store.
 DatabasePlugin newPlugin({Store? store}) {

package/dart-src/packages/cli-tools/test/pocketbase_installer_test.dart

@@ -0,0 +1,72 @@
+import 'dart:io';
+
+import 'package:flutter_ota_kit_cli/flutter_ota_kit_cli.dart';
+import 'package:path/path.dart' as p;
+import 'package:test/test.dart';
+
+void main() {
+  group('PocketBase install paths', () {
+    test('resolve returns a stable, versioned path', () {
+      final a = PocketBaseInstallPaths.resolve(version: '0.22.21');
+      final b = PocketBaseInstallPaths.resolve(version: '0.22.21');
+      expect(a.installDir.path, b.installDir.path);
+      expect(a.installDir.path, endsWith(p.join('pocketbase', '0.22.21')));
+      expect(
+        a.binaryPath.path,
+        anyOf(
+          endsWith(p.join('0.22.21', 'pocketbase')),
+          endsWith(p.join('0.22.21', 'pocketbase.exe')),
+        ),
+      );
+    });
+
+    test('resolve uses custom root', () {
+      final tmp = Directory.systemTemp.createTempSync('fp-pb-paths-');
+      final a = PocketBaseInstallPaths.resolve(version: '0.22.21', root: tmp);
+      expect(a.installDir.path, tmp.path);
+      tmp.deleteSync(recursive: true);
+    });
+  });
+
+  group('PocketBaseDataBootstrap', () {
+    test('copies .pb.js hooks on first run, leaves user edits alone', () async {
+      final tmp = Directory.systemTemp.createTempSync('fp-pb-data-');
+      final source = Directory(p.join(tmp.path, 'src'))
+        ..createSync(recursive: true);
+      File(p.join(source.path, 'bundles.pb.js'))
+          .writeAsStringSync('// hook v1');
+      final dataDir = Directory(p.join(tmp.path, 'data'))..createSync();
+
+      final bootstrap = PocketBaseDataBootstrap(
+        dataDir: dataDir,
+        hooksSourceDir: source,
+      );
+      final installed = await bootstrap.install();
+      expect(installed, ['bundles.pb.js']);
+      final copied = File(p.join(dataDir.path, 'pb_hooks', 'bundles.pb.js'));
+      expect(copied.existsSync(), isTrue);
+      expect(copied.readAsStringSync(), '// hook v1');
+
+      // User edits the copy; second install must not overwrite.
+      copied.writeAsStringSync('// user edit');
+      final second = await bootstrap.install();
+      expect(second, isEmpty);
+      expect(copied.readAsStringSync(), '// user edit');
+
+      tmp.deleteSync(recursive: true);
+    });
+
+    test('no-op when source dir does not exist', () async {
+      final tmp = Directory.systemTemp.createTempSync('fp-pb-data-');
+      final source = Directory(p.join(tmp.path, 'missing'));
+      final dataDir = Directory(p.join(tmp.path, 'data'))..createSync();
+      final bootstrap = PocketBaseDataBootstrap(
+        dataDir: dataDir,
+        hooksSourceDir: source,
+      );
+      final installed = await bootstrap.install();
+      expect(installed, isEmpty);
+      tmp.deleteSync(recursive: true);
+    });
+  });
+}

package/dart-src/packages/cli-tools/test/pocketbase_schema_test.dart

@@ -0,0 +1,107 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:flutter_ota_kit_cli/flutter_ota_kit_cli.dart';
+import 'package:test/test.dart';
+
+/// Minimal in-process HTTP server that simulates a PocketBase admin API.
+class _MockPocketBase {
+  _MockPocketBase._(this._server, this.baseUrl);
+
+  final HttpServer _server;
+  final String baseUrl;
+  final List<String> createdCollections = [];
+  List<String> existingCollections = const ['admins'];
+  bool authCalled = false;
+  String? lastAuthEmail;
+
+  static Future<_MockPocketBase> start() async {
+    final server = await HttpServer.bind(InternetAddress.loopbackIPv4, 0);
+    final mock = _MockPocketBase._(server, 'http://127.0.0.1:${server.port}');
+    server.listen(mock._handle);
+    return mock;
+  }
+
+  Future<void> stop() async {
+    await _server.close(force: true);
+  }
+
+  Future<void> _handle(HttpRequest req) async {
+    final path = req.uri.path;
+    if (path == '/api/admins/auth-with-password') {
+      authCalled = true;
+      final body = jsonDecode(await utf8.decoder.bind(req).join()) as Map;
+      lastAuthEmail = body['identity'] as String?;
+      req.response.headers.contentType = ContentType.json;
+      req.response.write(jsonEncode({'token': 'mock-token'}));
+      await req.response.close();
+      return;
+    }
+    if (path == '/api/collections' && req.method == 'GET') {
+      req.response.headers.contentType = ContentType.json;
+      req.response.write(
+        jsonEncode({
+          'items': [
+            for (final n in existingCollections) {'name': n},
+          ],
+        }),
+      );
+      await req.response.close();
+      return;
+    }
+    if (path == '/api/collections' && req.method == 'POST') {
+      final body = jsonDecode(await utf8.decoder.bind(req).join()) as Map;
+      createdCollections.add(body['name'] as String? ?? '?');
+      req.response.statusCode = 200;
+      req.response.write(jsonEncode({'id': 'mock'}));
+      await req.response.close();
+      return;
+    }
+    req.response.statusCode = 404;
+    await req.response.close();
+  }
+}
+
+void main() {
+  late _MockPocketBase mock;
+  setUp(() async {
+    mock = await _MockPocketBase.start();
+  });
+  tearDown(() async {
+    await mock.stop();
+  });
+
+  test(
+    'schema installer creates the three collections on a fresh PB',
+    () async {
+      final installer = PocketBaseSchemaInstaller(
+        url: mock.baseUrl,
+        adminEmail: 'admin@x.com',
+        adminPassword: 'secret',
+      );
+      final result = await installer.install();
+      expect(mock.authCalled, isTrue);
+      expect(mock.lastAuthEmail, 'admin@x.com');
+      expect(result.created, containsAll(['bundles', 'channels', 'audit_log']));
+      expect(result.skipped, isEmpty);
+      expect(
+        mock.createdCollections,
+        containsAll(['bundles', 'channels', 'audit_log']),
+      );
+    },
+  );
+
+  test('schema installer skips collections that already exist', () async {
+    mock.existingCollections = ['bundles', 'channels', 'audit_log'];
+    final installer = PocketBaseSchemaInstaller(
+      url: mock.baseUrl,
+      adminEmail: 'admin@x.com',
+      adminPassword: 'secret',
+    );
+    final result = await installer.install();
+    expect(result.skipped, containsAll(['bundles', 'channels', 'audit_log']));
+    expect(result.created, isEmpty);
+    expect(mock.createdCollections, isEmpty);
+  });
+}

package/dart-src/packages/cli-tools/test/pocketbase_smoke_test.dart

@@ -0,0 +1,59 @@
+import 'package:flutter_ota_kit_pocketbase/flutter_ota_kit_pocketbase.dart';
+import 'package:test/test.dart';
+
+import 'mocks/mock_pocketbase_client.dart' as pb;
+
+void main() {
+  test('parsePocketBaseStorageUri handles empty bucket', () {
+    final result = parsePocketBaseStorageUri('pb:///abc/file.zip');
+    expect(result, isNotNull);
+    expect(result!.recordId, 'abc');
+    expect(result.filename, 'file.zip');
+  });
+
+  test('parsePocketBaseStorageUri handles non-empty bucket', () {
+    final result = parsePocketBaseStorageUri('pb://bundles/abc/file.zip');
+    expect(result, isNotNull);
+    expect(result!.recordId, 'abc');
+    expect(result.filename, 'file.zip');
+    expect(result.bucket, 'bundles');
+  });
+
+  test('MockPocketBaseClient upload + exists round-trips', () async {
+    final store = pb.PocketBaseStore();
+    final client = pb.MockPocketBaseClient(store);
+    client.adminCredentials('admin@x.com', 'pw');
+
+    // Create a record.
+    await client.createRecord<dynamic>('bundles', {
+      'id': 'abc',
+      'channel': 'pending',
+      'platform': 'android',
+      'enabled': false,
+    }, (j) => j);
+
+    // Upload a file to it.
+    await client.uploadFile<dynamic>('bundles', 'abc', 'artifact', 'test.zip', [
+      1,
+      2,
+      3,
+    ], fromJson: (j) => j);
+
+    // Check exists.
+    expect(await client.recordExists('bundles', 'abc'), isTrue);
+    expect(await client.recordExists('bundles', 'nope'), isFalse);
+
+    // Duplicate create should fail (real PB would return 409).
+    expect(
+      () => client.createRecord<dynamic>('bundles', {
+        'id': 'abc',
+        'channel': 'production',
+      }, (j) => j),
+      throwsA(isA<PocketBaseException>()),
+    );
+
+    // Download the file.
+    final bytes = await client.downloadFile('pb://mock/bundles/abc/test.zip');
+    expect(bytes, [1, 2, 3]);
+  });
+}

package/dart-src/packages/core/README.md

@@ -1,6 +1,6 @@
 # flutter_ota_kit_core
 
-Pure-Dart core of the [flutter_ota_kit](https://github.com/HYPER12755/flutter_ota_kit) OTA toolkit. It has **no Flutter dependency** and is shared by every other package (client, plugin-core, and all four backends).
+Pure-Dart core of the [flutter_ota_kit](https://github.com/HYPER12755/flutter-ota-kit) OTA toolkit. It has **no Flutter dependency** and is shared by every other package (client, plugin-core, and all four backends).
 
 ## What's inside
 
@@ -20,4 +20,4 @@ final ok = semverSatisfies('1.0.0', '>=1.0.0 <2.0.0'); // true
 
 ## License
 
-MIT — see the [project LICENSE](https://github.com/HYPER12755/flutter_ota_kit/blob/main/LICENSE).
+MIT — see the [project LICENSE](https://github.com/HYPER12755/flutter-ota-kit/blob/main/LICENSE).

package/dart-src/packages/core/example/lib/main.dart

@@ -0,0 +1,69 @@
+// flutter_ota_kit_core example
+//
+// `flutter_ota_kit_core` is the framework-agnostic data model shared by every
+// backend plugin in the `flutter_ota_kit` family. It defines the canonical
+// shapes for bundles, patches, and rollouts.
+//
+// Most apps don't import this package directly — they use `flutter_ota_kit`
+// (the umbrella package) which re-exports it. This file shows the types you
+// might encounter in API responses, in `flutter_ota_kit_cli` tool output, or
+// while writing a custom backend.
+//
+// Run: `dart run example/main.dart`
+
+import 'package:flutter_ota_kit_core/flutter_ota_kit_core.dart';
+
+void main() {
+  // ── 1. Bundle: the central database row / manifest object. ─────────
+  // Every backend stores this shape (Postgres, Supabase, Cloudflare D1,
+  // AWS DynamoDB, PocketBase). The wire format is camelCase, the SQL
+  // format is snake_case — `fromJson` tolerates both.
+  final bundle = Bundle(
+    id: '01a059a6-7d3c-4f3e-8a2c-9c2e3a4b5d6e',
+    platform: Platform.android,
+    shouldForceUpdate: false,
+    enabled: true,
+    fileHash: '7c4a8d09ca3762af61e59520943dc26494f8941b',
+    storageUri: 'supabase-storage://flutter-ota-bundles/01a059a6/patch.zip',
+    channel: 'production',
+    targetAppVersion: '1.0.0',
+    metadata: const BundleMetadata(
+      appVersion: '1.0.1',
+      signature: 'ed25519:9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08',
+    ),
+    rolloutCohortCount: 100, // 10% of devices (per-mille 0..1000).
+  );
+
+  print('Bundle ${bundle.id} on ${bundle.platform.value}:');
+  print('  storageUri          = ${bundle.storageUri}');
+  print('  targetAppVersion    = ${bundle.targetAppVersion}');
+  print('  metadata.appVersion = ${bundle.metadata?.appVersion}');
+
+  // ── 2. Wire format conversion. ─────────────────────────────────────
+  // `toJson()` produces the camelCase wire payload sent over the
+  // hot-updater-compatible update-check HTTP contract.
+  final wire = bundle.toJson();
+  print('Wire payload keys: ${wire.keys.toList()}');
+
+  // `toSqlJson()` produces the snake_case row format used by SQL
+  // backends (Postgres / Supabase / D1 / DynamoDB).
+  final sql = bundle.toSqlJson();
+  print('SQL row keys: ${sql.keys.toList()}');
+
+  // ── 3. Rollout: per-mille 0..1000 cohort bucketing. ────────────────
+  // The same device fingerprint always lands in the same bucket across
+  // cold starts, so a 10% rollout stays at 10% even as users churn.
+  const bundleId = '01a059a6-7d3c-4f3e-8a2c-9c2e3a4b5d6e';
+  const rolloutCohortCount = 100; // 10% (per-mille).
+
+  for (final userId in const ['alice', 'bob', 'carol', 'dave', 'eve']) {
+    final cohort = getDefaultNumericCohort(userId);
+    final eligible = isCohortEligibleForUpdate(
+      bundleId,
+      cohort,
+      rolloutCohortCount,
+      null, // targetCohorts (null = percentage rollout)
+    );
+    print('user=$userId  cohort=$cohort  in 10% rollout? $eligible');
+  }
+}

package/dart-src/packages/core/lib/flutter_ota_kit_core.dart

@@ -26,4 +26,4 @@ export 'src/uuid.dart';
 // Bundle artifact helpers.
 export 'src/bundle_artifacts.dart';
 
-export 'src/patch_info.dart';
+export 'src/patch_info.dart';

package/dart-src/packages/core/lib/src/app_update_info.dart

@@ -68,25 +68,27 @@ class AppUpdateAvailableInfo extends AppUpdateInfo {
         signature: j['signature'] as String?,
         manifestUrl: j['manifestUrl'] as String?,
         manifestFileHash: j['manifestFileHash'] as String?,
-        changedAssets: (j['changedAssets'] as Map?)?.map((k, v) => MapEntry(
-              k as String,
-              ChangedAsset.fromJson((v as Map).cast<String, dynamic>()),
-            )),
+        changedAssets: (j['changedAssets'] as Map?)?.map(
+          (k, v) => MapEntry(
+            k as String,
+            ChangedAsset.fromJson((v as Map).cast<String, dynamic>()),
+          ),
+        ),
       );
 
   @override
   Map<String, dynamic> toJson() => {
-        'id': id,
-        'shouldForceUpdate': shouldForceUpdate,
-        'message': message,
-        'status': status.value,
-        'fileUrl': fileUrl,
-        'fileHash': fileHash,
-        if (signature != null) 'signature': signature,
-        if (manifestUrl != null) 'manifestUrl': manifestUrl,
-        if (manifestFileHash != null) 'manifestFileHash': manifestFileHash,
-        if (changedAssets != null) 'changedAssets': changedAssets,
-      };
+    'id': id,
+    'shouldForceUpdate': shouldForceUpdate,
+    'message': message,
+    'status': status.value,
+    'fileUrl': fileUrl,
+    'fileHash': fileHash,
+    if (signature != null) 'signature': signature,
+    if (manifestUrl != null) 'manifestUrl': manifestUrl,
+    if (manifestFileHash != null) 'manifestFileHash': manifestFileHash,
+    if (changedAssets != null) 'changedAssets': changedAssets,
+  };
 }
 
 /// Device-facing "nothing to do" — hot-updater `AppUpToDateInfo`.