@_nazmiforreal/flutter-ota 0.1.0 → 0.1.2

package/dart-src/plugins/plugin-core/lib/src/get_update_info.dart

@@ -0,0 +1,241 @@
+import 'package:flutter_patcher_core/flutter_patcher_core.dart';
+
+/// Build an [UpdateInfo] response from a [Bundle] and an [UpdateStatus].
+UpdateInfo _makeResponse(Bundle bundle, UpdateStatus status) {
+  return UpdateInfo(
+    id: bundle.id,
+    message: bundle.message,
+    shouldForceUpdate: status == UpdateStatus.rollback
+        ? true
+        : bundle.shouldForceUpdate,
+    status: status,
+    storageUri: bundle.storageUri,
+    fileHash: bundle.fileHash,
+  );
+}
+
+/// Whether [bundle] is eligible for the user in [cohort].
+bool _isEligibleUpdateCandidate(Bundle bundle, String? cohort) {
+  return isCohortEligibleForUpdate(
+    bundle.id,
+    cohort,
+    bundle.rolloutCohortCount,
+    bundle.targetCohorts,
+  );
+}
+
+/// Find the bundle with the largest ID that is newer than [bundleId]
+/// and cohort-eligible.
+Bundle? _findLatestEligibleUpdateCandidate(
+  List<Bundle> bundles,
+  String bundleId,
+  String? cohort,
+) {
+  Bundle? updateCandidate;
+
+  for (final bundle in bundles) {
+    if (bundle.id.compareTo(bundleId) > 0 &&
+        _isEligibleUpdateCandidate(bundle, cohort) &&
+        (updateCandidate == null ||
+            bundle.id.compareTo(updateCandidate.id) > 0)) {
+      updateCandidate = bundle;
+    }
+  }
+
+  return updateCandidate;
+}
+
+/// Default rollback response for init bundles (id = nilUuid).
+const UpdateInfo _initBundleRollbackUpdateInfo = UpdateInfo(
+  message: null,
+  id: '00000000-0000-0000-0000-000000000000',
+  shouldForceUpdate: true,
+  status: UpdateStatus.rollback,
+  storageUri: null,
+  fileHash: null,
+);
+
+/// Resolve update info using the app-version strategy.
+Future<UpdateInfo?> _appVersionStrategy(
+  List<Bundle> bundles,
+  AppVersionGetBundlesArgs args,
+) async {
+  final channel = args.channel;
+  final minBundleId = args.minBundleId;
+  final platform = args.platform;
+  final appVersion = args.appVersion;
+  final bundleId = args.bundleId;
+  final cohort = args.cohort;
+
+  final candidateBundles = <Bundle>[];
+
+  for (final b in bundles) {
+    if (b.platform != platform ||
+        b.channel != channel ||
+        b.targetAppVersion == null ||
+        !semverSatisfies(b.targetAppVersion!, appVersion) ||
+        !b.enabled ||
+        (minBundleId.isNotEmpty && b.id.compareTo(minBundleId) < 0)) {
+      continue;
+    }
+    candidateBundles.add(b);
+  }
+
+  if (candidateBundles.isEmpty) {
+    if (bundleId == nilUuid ||
+        (minBundleId.isNotEmpty && bundleId.compareTo(minBundleId) <= 0)) {
+      return null;
+    }
+    return _initBundleRollbackUpdateInfo;
+  }
+
+  Bundle? rollbackCandidate;
+  Bundle? currentBundle;
+
+  for (final b in candidateBundles) {
+    if (b.id == bundleId) {
+      currentBundle = b;
+    } else if (bundleId != nilUuid && b.id.compareTo(bundleId) < 0) {
+      if (rollbackCandidate == null ||
+          b.id.compareTo(rollbackCandidate.id) > 0) {
+        rollbackCandidate = b;
+      }
+    }
+  }
+
+  final updateCandidate = _findLatestEligibleUpdateCandidate(
+    candidateBundles,
+    bundleId,
+    cohort,
+  );
+  final currentBundleEligible =
+      currentBundle != null &&
+      _isEligibleUpdateCandidate(currentBundle, cohort);
+
+  if (bundleId == nilUuid) {
+    if (updateCandidate != null) {
+      return _makeResponse(updateCandidate, UpdateStatus.update);
+    }
+    return null;
+  }
+
+  if (currentBundleEligible) {
+    if (updateCandidate != null) {
+      return _makeResponse(updateCandidate, UpdateStatus.update);
+    }
+    return null;
+  }
+
+  if (updateCandidate != null) {
+    return _makeResponse(updateCandidate, UpdateStatus.update);
+  }
+  if (rollbackCandidate != null) {
+    return _makeResponse(rollbackCandidate, UpdateStatus.rollback);
+  }
+
+  if (minBundleId.isNotEmpty && bundleId.compareTo(minBundleId) <= 0) {
+    return null;
+  }
+  return _initBundleRollbackUpdateInfo;
+}
+
+/// Resolve update info using the fingerprint strategy.
+Future<UpdateInfo?> _fingerprintStrategy(
+  List<Bundle> bundles,
+  FingerprintGetBundlesArgs args,
+) async {
+  final channel = args.channel;
+  final minBundleId = args.minBundleId;
+  final platform = args.platform;
+  final fingerprintHash = args.fingerprintHash;
+  final bundleId = args.bundleId;
+  final cohort = args.cohort;
+
+  final candidateBundles = <Bundle>[];
+
+  for (final b in bundles) {
+    if (b.platform != platform ||
+        b.channel != channel ||
+        b.fingerprintHash == null ||
+        b.fingerprintHash != fingerprintHash ||
+        !b.enabled ||
+        (minBundleId.isNotEmpty && b.id.compareTo(minBundleId) < 0)) {
+      continue;
+    }
+    candidateBundles.add(b);
+  }
+
+  if (candidateBundles.isEmpty) {
+    if (bundleId == nilUuid ||
+        (minBundleId.isNotEmpty && bundleId.compareTo(minBundleId) <= 0)) {
+      return null;
+    }
+    return _initBundleRollbackUpdateInfo;
+  }
+
+  Bundle? rollbackCandidate;
+  Bundle? currentBundle;
+
+  for (final b in candidateBundles) {
+    if (b.id == bundleId) {
+      currentBundle = b;
+    } else if (bundleId != nilUuid && b.id.compareTo(bundleId) < 0) {
+      if (rollbackCandidate == null ||
+          b.id.compareTo(rollbackCandidate.id) > 0) {
+        rollbackCandidate = b;
+      }
+    }
+  }
+
+  final updateCandidate = _findLatestEligibleUpdateCandidate(
+    candidateBundles,
+    bundleId,
+    cohort,
+  );
+  final currentBundleEligible =
+      currentBundle != null &&
+      _isEligibleUpdateCandidate(currentBundle, cohort);
+
+  if (bundleId == nilUuid) {
+    if (updateCandidate != null) {
+      return _makeResponse(updateCandidate, UpdateStatus.update);
+    }
+    return null;
+  }
+
+  if (currentBundleEligible) {
+    if (updateCandidate != null) {
+      return _makeResponse(updateCandidate, UpdateStatus.update);
+    }
+    return null;
+  }
+
+  if (updateCandidate != null) {
+    return _makeResponse(updateCandidate, UpdateStatus.update);
+  }
+  if (rollbackCandidate != null) {
+    return _makeResponse(rollbackCandidate, UpdateStatus.rollback);
+  }
+
+  if (minBundleId.isNotEmpty && bundleId.compareTo(minBundleId) <= 0) {
+    return null;
+  }
+  return _initBundleRollbackUpdateInfo;
+}
+
+/// Resolve update information from a list of candidate bundles.
+///
+/// Dispatches to [AppVersionGetBundlesArgs] or [FingerprintGetBundlesArgs]
+/// strategy based on [args].
+Future<UpdateInfo?> getUpdateInfo(
+  List<Bundle> bundles,
+  GetBundlesArgs args,
+) async {
+  if (args is AppVersionGetBundlesArgs) {
+    return _appVersionStrategy(bundles, args);
+  }
+  if (args is FingerprintGetBundlesArgs) {
+    return _fingerprintStrategy(bundles, args);
+  }
+  return null;
+}

package/dart-src/plugins/plugin-core/lib/src/is_object.dart

@@ -0,0 +1,5 @@
+/// Check whether a value is a plain Dart Map (not a List, not a class instance
+/// with a different runtimeType).
+///
+/// Faithful port of hot-updater `isObject.ts`.
+bool isObject(Object? value) => value is Map<String, Object?>;

package/dart-src/plugins/plugin-core/lib/src/legacy_asset_storage_layout.dart

@@ -0,0 +1,9 @@
+/// @internal
+///
+/// Legacy manifest assets were stored below each bundle's `/files` directory
+/// using their manifest-relative path. Keep all old-layout path decisions here
+/// so support can be removed by deleting this module and the entrypoint branch
+/// that imports it.
+String getLegacyManifestAssetStoragePath({required String assetPath}) {
+  return assetPath;
+}

package/dart-src/plugins/plugin-core/lib/src/paginate_bundles.dart

@@ -0,0 +1,112 @@
+import 'calculate_pagination.dart';
+import 'query_bundles.dart';
+import 'types.dart';
+
+/// Paginate a list of bundles using offset or cursor-based pagination.
+///
+/// Faithful port of hot-updater `paginateBundles.ts`.
+Paginated<List<Bundle>> paginateBundles({
+  required List<Bundle> bundles,
+  required int limit,
+  int? offset,
+  DatabaseBundleCursor? cursor,
+  DatabaseBundleQueryOrder? orderBy,
+}) {
+  final sortedBundles = sortBundles(bundles, orderBy);
+  final direction = orderBy?.direction ?? 'desc';
+  final total = sortedBundles.length;
+
+  // Offset-based pagination
+  if (offset != null) {
+    final normalizedOffset = offset < 0 ? 0 : offset;
+    final data = limit > 0
+        ? sortedBundles.sublist(
+            normalizedOffset,
+            normalizedOffset + limit > total ? total : normalizedOffset + limit,
+          )
+        : sortedBundles.sublist(normalizedOffset);
+    final pagination = calculatePagination(total, limit: limit, offset: normalizedOffset);
+    final nextCursor =
+        data.isNotEmpty && normalizedOffset + data.length < total
+            ? data.last.id
+            : null;
+    final previousCursor =
+        data.isNotEmpty && normalizedOffset > 0 ? data.first.id : null;
+
+    return Paginated(
+      data: data,
+      pagination: PaginationInfo(
+        total: pagination.total,
+        hasNextPage: pagination.hasNextPage,
+        hasPreviousPage: pagination.hasPreviousPage,
+        currentPage: pagination.currentPage,
+        totalPages: pagination.totalPages,
+        nextCursor: nextCursor,
+        previousCursor: previousCursor,
+      ),
+    );
+  }
+
+  // Cursor-based pagination
+  List<Bundle> data;
+  if (cursor?.after != null) {
+    final candidates = sortedBundles.where((bundle) {
+      return direction == 'desc'
+          ? bundle.id.compareTo(cursor!.after!) < 0
+          : bundle.id.compareTo(cursor!.after!) > 0;
+    }).toList();
+    data = limit > 0 ? candidates.sublist(0, limit > candidates.length ? candidates.length : limit) : candidates;
+  } else if (cursor?.before != null) {
+    final candidates = sortedBundles.where((bundle) {
+      return direction == 'desc'
+          ? bundle.id.compareTo(cursor!.before!) > 0
+          : bundle.id.compareTo(cursor!.before!) < 0;
+    }).toList();
+    data = limit > 0
+        ? candidates.sublist(
+            candidates.length - limit > 0 ? candidates.length - limit : 0,
+          )
+        : candidates;
+  } else {
+    data = limit > 0
+        ? sortedBundles.sublist(0, limit > total ? total : limit)
+        : List.from(sortedBundles);
+  }
+
+  final startIndex = data.isNotEmpty
+      ? sortedBundles.indexWhere((b) => b.id == data.first.id)
+      : cursor?.after != null
+          ? total
+          : 0;
+  final pagination = calculatePagination(total, limit: limit, offset: startIndex);
+  final nextCursor =
+      data.isNotEmpty && startIndex + data.length < total
+          ? data.last.id
+          : null;
+  final previousCursor =
+      data.isNotEmpty && startIndex > 0 ? data.first.id : null;
+
+  String? effectiveNextCursor = nextCursor;
+  String? effectivePreviousCursor = previousCursor;
+
+  // Edge case: empty result after cursor → preserve the cursor for navigation
+  if (data.isEmpty && cursor?.after != null) {
+    effectivePreviousCursor = cursor!.after;
+  }
+  if (data.isEmpty && cursor?.before != null) {
+    effectiveNextCursor = cursor!.before;
+  }
+
+  return Paginated(
+    data: data,
+    pagination: PaginationInfo(
+      total: pagination.total,
+      hasNextPage: pagination.hasNextPage,
+      hasPreviousPage: pagination.hasPreviousPage,
+      currentPage: pagination.currentPage,
+      totalPages: pagination.totalPages,
+      nextCursor: effectiveNextCursor,
+      previousCursor: effectivePreviousCursor,
+    ),
+  );
+}

package/dart-src/plugins/plugin-core/lib/src/parse_storage_uri.dart

@@ -0,0 +1,44 @@
+/// Parsed components of a storage URI.
+class ParsedStorageUri {
+  const ParsedStorageUri({
+    required this.protocol,
+    required this.bucket,
+    required this.key,
+  });
+
+  final String protocol;
+  final String bucket;
+  final String key;
+}
+
+/// Decode percent-encoded storage object keys.
+String decodeStorageObjectKey(String key) {
+  try {
+    return Uri.decodeComponent(key);
+  } catch (_) {
+    return key;
+  }
+}
+
+/// Parse a storage URI and validate the protocol.
+///
+/// Example: `parseStorageUri("s3://my-bucket/path/to/file.zip", "s3")`
+///   → `{ protocol: "s3", bucket: "my-bucket", key: "path/to/file.zip" }`
+///
+/// Faithful port of hot-updater `parseStorageUri.ts`.
+ParsedStorageUri parseStorageUri(String storageUri, String expectedProtocol) {
+  final uri = Uri.parse(storageUri);
+  final protocol = uri.scheme;
+
+  if (protocol != expectedProtocol) {
+    throw FormatException(
+      'Invalid storage URI protocol. Expected $expectedProtocol, got $protocol',
+    );
+  }
+
+  return ParsedStorageUri(
+    protocol: protocol,
+    bucket: uri.host,
+    key: decodeStorageObjectKey(uri.path.startsWith('/') ? uri.path.substring(1) : uri.path),
+  );
+}

package/dart-src/plugins/plugin-core/lib/src/query_bundles.dart

@@ -0,0 +1,70 @@
+import 'types.dart';
+
+/// Compare a bundle ID field against an expected value with a comparator.
+bool _compareValue(String value, String? expected, String comparator) {
+  if (expected == null) return true;
+  final cmp = value.compareTo(expected);
+  switch (comparator) {
+    case 'eq':
+      return cmp == 0;
+    case 'gt':
+      return cmp > 0;
+    case 'gte':
+      return cmp >= 0;
+    case 'lt':
+      return cmp < 0;
+    case 'lte':
+      return cmp <= 0;
+    default:
+      return true;
+  }
+}
+
+/// Check whether a bundle ID matches the given filter.
+bool bundleIdMatchesFilter(String id, DatabaseBundleIdFilter? filter) {
+  if (filter == null) return true;
+  if (filter.ins != null && !filter.ins!.contains(id)) return false;
+  return _compareValue(id, filter.eq, 'eq') &&
+      _compareValue(id, filter.gt, 'gt') &&
+      _compareValue(id, filter.gte, 'gte') &&
+      _compareValue(id, filter.lt, 'lt') &&
+      _compareValue(id, filter.lte, 'lte');
+}
+
+/// Check whether a bundle matches all fields in a where clause.
+bool bundleMatchesQueryWhere(Bundle bundle, DatabaseBundleQueryWhere? where) {
+  if (where == null) return true;
+  if (where.channel != null && bundle.channel != where.channel) return false;
+  if (where.platform != null && bundle.platform != where.platform) return false;
+  if (where.enabled != null && bundle.enabled != where.enabled) return false;
+  if (!bundleIdMatchesFilter(bundle.id, where.id)) return false;
+  if (where.targetAppVersionNotNull == true &&
+      bundle.targetAppVersion == null) {
+    return false;
+  }
+  if (where.targetAppVersion != null &&
+      bundle.targetAppVersion != where.targetAppVersion) {
+    return false;
+  }
+  if (where.targetAppVersionIn != null &&
+      !where.targetAppVersionIn!
+          .contains(bundle.targetAppVersion ?? '')) {
+    return false;
+  }
+  if (where.fingerprintHash != null &&
+      bundle.fingerprintHash != where.fingerprintHash) {
+    return false;
+  }
+  return true;
+}
+
+/// Sort bundles by ID in the specified direction.
+List<Bundle> sortBundles(List<Bundle> bundles, DatabaseBundleQueryOrder? orderBy) {
+  final direction = orderBy?.direction ?? 'desc';
+  final sorted = List<Bundle>.from(bundles);
+  sorted.sort((a, b) {
+    final result = a.id.compareTo(b.id);
+    return direction == 'asc' ? result : -result;
+  });
+  return sorted;
+}

package/dart-src/plugins/plugin-core/lib/src/request_update_bundle_state.dart

@@ -0,0 +1,62 @@
+import 'package:flutter_patcher_core/flutter_patcher_core.dart' show Bundle;
+
+import 'bundle_unit_of_work.dart';
+import 'bundle_unit_of_work_store.dart';
+
+/// Resolver interface for looking up bundles within a request context.
+abstract class RequestUpdateBundleResolver {
+  bool get hasSeededBundles;
+  Bundle? peek(String bundleId);
+  Future<Bundle?> getById(
+    String bundleId,
+    Future<Bundle?> Function() loadBundleById,
+  );
+}
+
+List<Bundle> _toSeeds(List<Bundle?> seeds) =>
+    seeds.whereType<Bundle>().toList();
+
+/// Seed bundles into the unit of work for a given context.
+void seedRequestUpdateBundles(
+  Map<String, Object?>? context,
+  List<Bundle?> seeds,
+) {
+  final unitOfWork = getRequestBundleUnitOfWork(context);
+  if (unitOfWork == null) return;
+  final nextSeeds = _toSeeds(seeds);
+  if (nextSeeds.isEmpty) return;
+  unitOfWork.seed(nextSeeds);
+}
+
+/// Return the seeded bundles for the given context.
+List<Bundle> getRequestUpdateBundleSeeds(Map<String, Object?>? context) {
+  return getRequestBundleUnitOfWork(context)?.seededBundles() ?? const [];
+}
+
+/// Create a resolver backed by a BundleUnitOfWork.
+RequestUpdateBundleResolver createRequestUpdateBundleResolver(
+  Map<String, Object?>? context,
+) {
+  final unitOfWork =
+      getRequestBundleUnitOfWork(context) ?? BundleUnitOfWork();
+  return _RequestUpdateBundleResolverImpl(unitOfWork);
+}
+
+class _RequestUpdateBundleResolverImpl implements RequestUpdateBundleResolver {
+  _RequestUpdateBundleResolverImpl(this._unitOfWork);
+
+  final BundleUnitOfWork _unitOfWork;
+
+  @override
+  bool get hasSeededBundles => _unitOfWork.hasSeeds();
+
+  @override
+  Bundle? peek(String bundleId) => _unitOfWork.peek(bundleId);
+
+  @override
+  Future<Bundle?> getById(
+    String bundleId,
+    Future<Bundle?> Function() loadBundleById,
+  ) =>
+      _unitOfWork.getById(bundleId, loadBundleById);
+}

package/dart-src/plugins/plugin-core/lib/src/resolve_update_info_from_bundles.dart

@@ -0,0 +1,43 @@
+import 'package:flutter_patcher_core/flutter_patcher_core.dart'
+    show Bundle, GetBundlesArgs, UpdateInfo, nilUuid;
+
+import 'get_update_info.dart' show getUpdateInfo;
+import 'request_update_bundle_state.dart' show seedRequestUpdateBundles;
+
+/// Options for [resolveUpdateInfoFromBundles].
+class ResolveUpdateInfoFromBundlesOptions {
+  const ResolveUpdateInfoFromBundlesOptions({
+    required this.args,
+    required this.bundles,
+    this.context,
+  });
+
+  final GetBundlesArgs args;
+  final List<Bundle> bundles;
+  final Map<String, Object?>? context;
+}
+
+Bundle? _findSeedBundle(List<Bundle> bundles, String bundleId) {
+  for (final bundle in bundles) {
+    if (bundle.id == bundleId) return bundle;
+  }
+  return null;
+}
+
+/// Resolve update information from pre-loaded bundles and seed the
+/// request unit of work with the matched bundles.
+Future<UpdateInfo?> resolveUpdateInfoFromBundles(
+  ResolveUpdateInfoFromBundlesOptions options,
+) async {
+  final info = await getUpdateInfo(options.bundles, options.args);
+  if (info == null) return null;
+
+  seedRequestUpdateBundles(options.context, [
+    _findSeedBundle(options.bundles, info.id),
+    options.args.bundleId == nilUuid
+        ? null
+        : _findSeedBundle(options.bundles, options.args.bundleId),
+  ]);
+
+  return info;
+}

package/dart-src/plugins/plugin-core/lib/src/storage_profile.dart

@@ -0,0 +1,27 @@
+import 'types.dart';
+
+/// Check whether a storage plugin provides a node profile.
+bool isNodeStoragePlugin(StoragePlugin plugin) => plugin.profiles.hasNode;
+
+/// Check whether a storage plugin provides a runtime profile.
+bool isRuntimeStoragePlugin(StoragePlugin plugin) => plugin.profiles.hasRuntime;
+
+/// Assert that a storage plugin provides a node profile.
+void assertNodeStoragePlugin(StoragePlugin plugin) {
+  if (!isNodeStoragePlugin(plugin)) {
+    throw StateError(
+      '${plugin.name} does not implement the node storage profile '
+      'for protocol "${plugin.supportedProtocol}".',
+    );
+  }
+}
+
+/// Assert that a storage plugin provides a runtime profile.
+void assertRuntimeStoragePlugin(StoragePlugin plugin) {
+  if (!isRuntimeStoragePlugin(plugin)) {
+    throw StateError(
+      '${plugin.name} does not implement the runtime storage profile '
+      'for protocol "${plugin.supportedProtocol}".',
+    );
+  }
+}