@_nazmiforreal/flutter-ota 0.1.0 → 0.1.2

package/dart-src/plugins/postgres/lib/src/postgres_storage.dart

@@ -0,0 +1,205 @@
+import 'dart:convert';
+import 'dart:io';
+import 'dart:typed_data';
+
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart';
+
+import 'postgres_client.dart';
+import 'postgres_config.dart';
+
+/// Configuration for the Postgres bytea storage plugin.
+///
+/// Reuses the same [PostgresConfig] connection as the database plugin. Blob
+/// bytes are stored in a `flutter_patcher_storage(key text primary key, data
+/// bytea, content_type text)` table. Because Postgres cannot serve bytes over
+/// HTTP itself, [servingBaseUrl] may point at a thin proxy that reads from this
+/// table so device update-checks can download over HTTP (the CLI/console supply
+/// one; tests mount a local server).
+class PostgresStorageConfig {
+  const PostgresStorageConfig({
+    required this.db,
+    this.basePath,
+    this.servingBaseUrl,
+  });
+
+  final PostgresConfig db;
+  final String? basePath;
+  final String? servingBaseUrl;
+}
+
+/// Resolves the storage client for a config (test seam via [PostgresConfig.clientFactory]).
+PostgresClientLike resolvePostgresStorageClient(PostgresStorageConfig config) =>
+    config.db.clientFactory?.call(config.db) ?? PostgresClient.connect(config.db);
+
+String _storageUri(String key, String? servingBaseUrl) {
+  if (servingBaseUrl != null && servingBaseUrl.isNotEmpty) {
+    final base = servingBaseUrl.endsWith('/')
+        ? servingBaseUrl.substring(0, servingBaseUrl.length - 1)
+        : servingBaseUrl;
+    return '$base/$key';
+  }
+  return 'postgres://$key';
+}
+
+String _contentType(String key) {
+  if (key.endsWith('.json')) return 'application/json';
+  if (key.endsWith('.zip')) return 'application/zip';
+  return 'application/octet-stream';
+}
+
+String _strip(String storageUri, String? servingBaseUrl) {
+  if (storageUri.startsWith('postgres://')) {
+    return storageUri.substring('postgres://'.length);
+  }
+  if (servingBaseUrl != null && storageUri.startsWith(servingBaseUrl)) {
+    final base =
+        servingBaseUrl.endsWith('/') ? servingBaseUrl : '$servingBaseUrl/';
+    return storageUri.startsWith(base)
+        ? storageUri.substring(base.length)
+        : storageUri;
+  }
+  return storageUri;
+}
+
+Uint8List _toBytes(Object? data) {
+  if (data is Uint8List) return data;
+  if (data is List) return Uint8List.fromList(data.cast<int>());
+  return Uint8List(0);
+}
+
+NodeStorageProfile createPostgresNodeProfile(
+  PostgresClientLike client,
+  String? basePath,
+  String? servingBaseUrl,
+) =>
+    _PostgresNodeProfile(client, basePath, servingBaseUrl);
+
+class _PostgresNodeProfile implements NodeStorageProfile {
+  _PostgresNodeProfile(this._client, this._basePath, this._servingBaseUrl);
+
+  final PostgresClientLike _client;
+  final String? _basePath;
+  final String? _servingBaseUrl;
+
+  String _withBase(String key) =>
+      [_basePath, key].where((s) => s != null && s.isNotEmpty).join('/');
+
+  @override
+  Future<Map<String, String>> upload(String key, String filePath) async {
+    final fullKey = _withBase(key);
+    final bytes = await File(filePath).readAsBytes();
+    await _client.execute(
+      'INSERT INTO flutter_patcher_storage (key, data, content_type) '
+      'VALUES (@key, @data, @ct) '
+      'ON CONFLICT (key) DO UPDATE SET data = EXCLUDED.data, content_type = EXCLUDED.content_type',
+      {
+        '@key': fullKey,
+        '@data': bytes,
+        '@ct': _contentType(fullKey),
+      },
+    );
+    return {'storageUri': _storageUri(fullKey, _servingBaseUrl)};
+  }
+
+  @override
+  Future<bool> exists(String storageUri) async {
+    final key = _strip(storageUri, _servingBaseUrl);
+    final rows = await _client.execute(
+      'SELECT 1 FROM flutter_patcher_storage WHERE key = @key',
+      {'@key': key},
+    );
+    return rows.isNotEmpty;
+  }
+
+  @override
+  Future<void> delete(String storageUri) async {
+    await _client.execute(
+      'DELETE FROM flutter_patcher_storage WHERE key = @key',
+      {'@key': _strip(storageUri, _servingBaseUrl)},
+    );
+  }
+
+  @override
+  Future<void> downloadFile(String storageUri, String filePath) async {
+    final key = _strip(storageUri, _servingBaseUrl);
+    final rows = await _client.execute(
+      'SELECT data FROM flutter_patcher_storage WHERE key = @key',
+      {'@key': key},
+    );
+    if (rows.isEmpty) {
+      throw StateError('Object not found: $key');
+    }
+    await File(filePath).writeAsBytes(_toBytes(rows.first['data']));
+  }
+
+  @override
+  Future<List<StorageObject>> listObjects([String? prefix]) async {
+    final fullPrefix = prefix == null ? null : _withBase(prefix);
+    final rows = await _client.execute(
+      'SELECT key, octet_length(data) AS size FROM flutter_patcher_storage '
+      'WHERE key LIKE @prefix',
+      {'@prefix': '${fullPrefix ?? ''}%'},
+    );
+    return rows.map((r) {
+      final key = r['key'] as String;
+      return StorageObject(
+        key: key,
+        storageUri: _storageUri(key, _servingBaseUrl),
+        size: (r['size'] as int?) ?? 0,
+      );
+    }).toList();
+  }
+
+  @override
+  Future<void> deleteObjects(List<String> keys) async {
+    for (final k in keys) {
+      await _client.execute(
+        'DELETE FROM flutter_patcher_storage WHERE key = @key',
+        {'@key': _strip(k, _servingBaseUrl)},
+      );
+    }
+  }
+}
+
+RuntimeStorageProfile createPostgresRuntimeProfile(
+  PostgresClientLike client,
+  String? servingBaseUrl,
+) =>
+    _PostgresRuntimeProfile(client, servingBaseUrl);
+
+class _PostgresRuntimeProfile implements RuntimeStorageProfile {
+  _PostgresRuntimeProfile(this._client, this._servingBaseUrl);
+
+  final PostgresClientLike _client;
+  final String? _servingBaseUrl;
+
+  @override
+  Future<Map<String, String>> getDownloadUrl(String storageUri) async {
+    return {'fileUrl': _storageUri(_strip(storageUri, _servingBaseUrl), _servingBaseUrl)};
+  }
+
+  @override
+  Future<String?> readText(String storageUri) async {
+    final key = _strip(storageUri, _servingBaseUrl);
+    final rows = await _client.execute(
+      'SELECT data FROM flutter_patcher_storage WHERE key = @key',
+      {'@key': key},
+    );
+    if (rows.isEmpty) return null;
+    return utf8.decode(_toBytes(rows.first['data']));
+  }
+}
+
+/// Postgres bytea storage plugin (name `postgresStorage`, protocol `postgres`).
+StoragePlugin Function(PostgresStorageConfig) postgresStorage =
+    createUniversalStoragePlugin<PostgresStorageConfig>(
+      name: 'postgresStorage',
+      supportedProtocol: 'postgres',
+      factory: (cfg) {
+        final client = resolvePostgresStorageClient(cfg);
+        return (
+          node: createPostgresNodeProfile(client, cfg.basePath, cfg.servingBaseUrl),
+          runtime: createPostgresRuntimeProfile(client, cfg.servingBaseUrl),
+        );
+      },
+    );

package/dart-src/plugins/postgres/lib/src/postgres_types.dart

@@ -0,0 +1,132 @@
+import 'package:flutter_patcher_core/flutter_patcher_core.dart'
+    show Platform;
+
+/// Database row for the `bundles` table (snake_case columns).
+///
+/// Faithful port of hot-updater `postgres/src/types.ts` `PostgresBundleRow`.
+class PostgresBundleRow {
+  const PostgresBundleRow({
+    required this.id,
+    required this.channel,
+    required this.enabled,
+    required this.shouldForceUpdate,
+    required this.fileHash,
+    this.gitCommitHash,
+    this.message,
+    required this.platform,
+    this.targetAppVersion,
+    required this.storageUri,
+    this.fingerprintHash,
+    this.metadata,
+    this.manifestStorageUri,
+    this.manifestFileHash,
+    this.assetBaseStorageUri,
+    this.rolloutCohortCount,
+    this.targetCohorts,
+  });
+
+  factory PostgresBundleRow.fromJson(Map<String, dynamic> json) {
+    return PostgresBundleRow(
+      id: json['id'] as String,
+      channel: json['channel'] as String,
+      enabled: json['enabled'] as bool,
+      shouldForceUpdate: json['should_force_update'] as bool,
+      fileHash: json['file_hash'] as String,
+      gitCommitHash: json['git_commit_hash'] as String?,
+      message: json['message'] as String?,
+      platform: Platform.fromValue(json['platform'] as String),
+      targetAppVersion: json['target_app_version'] as String?,
+      storageUri: json['storage_uri'] as String,
+      fingerprintHash: json['fingerprint_hash'] as String?,
+      metadata: json['metadata'],
+      manifestStorageUri: json['manifest_storage_uri'] as String?,
+      manifestFileHash: json['manifest_file_hash'] as String?,
+      assetBaseStorageUri: json['asset_base_storage_uri'] as String?,
+      rolloutCohortCount: json['rollout_cohort_count'] as int?,
+      targetCohorts: (json['target_cohorts'] as List?)?.cast<String>(),
+    );
+  }
+
+  final String id;
+  final String channel;
+  final bool enabled;
+  final bool shouldForceUpdate;
+  final String fileHash;
+  final String? gitCommitHash;
+  final String? message;
+  final Platform platform;
+  final String? targetAppVersion;
+  final String storageUri;
+  final String? fingerprintHash;
+  final dynamic metadata;
+  final String? manifestStorageUri;
+  final String? manifestFileHash;
+  final String? assetBaseStorageUri;
+  final int? rolloutCohortCount;
+  final List<String>? targetCohorts;
+
+  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.name,
+        'target_app_version': targetAppVersion,
+        'storage_uri': storageUri,
+        'fingerprint_hash': fingerprintHash,
+        'metadata': metadata ?? const {},
+        'manifest_storage_uri': manifestStorageUri,
+        'manifest_file_hash': manifestFileHash,
+        'asset_base_storage_uri': assetBaseStorageUri,
+        'rollout_cohort_count': rolloutCohortCount,
+        'target_cohorts': targetCohorts,
+      };
+}
+
+/// Database row for the `bundle_patches` table (snake_case columns).
+///
+/// Faithful port of hot-updater `postgres/src/types.ts` `PostgresBundlePatchRow`.
+class PostgresBundlePatchRow {
+  const PostgresBundlePatchRow({
+    required this.id,
+    required this.bundleId,
+    required this.baseBundleId,
+    required this.baseFileHash,
+    required this.patchFileHash,
+    required this.patchStorageUri,
+    required this.orderIndex,
+  });
+
+  factory PostgresBundlePatchRow.fromJson(Map<String, dynamic> json) {
+    return PostgresBundlePatchRow(
+      id: json['id'] as String,
+      bundleId: json['bundle_id'] as String,
+      baseBundleId: json['base_bundle_id'] as String,
+      baseFileHash: json['base_file_hash'] as String,
+      patchFileHash: json['patch_file_hash'] as String,
+      patchStorageUri: json['patch_storage_uri'] as String,
+      orderIndex: json['order_index'] as int,
+    );
+  }
+
+  final String id;
+  final String bundleId;
+  final String baseBundleId;
+  final String baseFileHash;
+  final String patchFileHash;
+  final String patchStorageUri;
+  final int orderIndex;
+
+  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/postgres/pubspec.yaml

@@ -0,0 +1,18 @@
+name: flutter_patcher_postgres
+description: Postgres plugin for flutter_patcher — database backend.
+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
+  postgres: ^3.4.0
+
+dev_dependencies:
+  test: ^1.25.0
+  lints: ^4.0.0

package/dart-src/plugins/postgres/sql/bundles.sql

@@ -0,0 +1,45 @@
+-- HotUpdater.bundles
+
+CREATE TYPE platforms AS ENUM ('ios', 'android');
+
+CREATE TABLE bundles (
+    id uuid PRIMARY KEY,
+    platform platforms NOT NULL,
+    should_force_update boolean NOT NULL,
+    enabled boolean NOT NULL,
+    file_hash text NOT NULL,
+    git_commit_hash text,
+    message text,
+    channel text NOT NULL DEFAULT 'production',
+    storage_uri text NOT NULL,
+    target_app_version text,
+    fingerprint_hash text,
+    CONSTRAINT check_version_or_fingerprint CHECK (
+        (target_app_version IS NOT NULL) OR (fingerprint_hash IS NOT NULL)
+    ),
+    metadata jsonb DEFAULT '{}'::jsonb,
+    manifest_storage_uri text,
+    manifest_file_hash text,
+    asset_base_storage_uri text,
+    rollout_cohort_count INTEGER DEFAULT 1000
+      CHECK (rollout_cohort_count >= 0 AND rollout_cohort_count <= 1000),
+    target_cohorts TEXT[]
+);
+
+CREATE TABLE bundle_patches (
+    id text PRIMARY KEY,
+    bundle_id uuid NOT NULL REFERENCES bundles(id) ON DELETE CASCADE,
+    base_bundle_id uuid NOT NULL REFERENCES bundles(id) ON DELETE CASCADE,
+    base_file_hash text NOT NULL,
+    patch_file_hash text NOT NULL,
+    patch_storage_uri text NOT NULL,
+    order_index integer NOT NULL DEFAULT 0
+);
+
+CREATE INDEX bundles_target_app_version_idx ON bundles(target_app_version);
+CREATE INDEX bundles_fingerprint_hash_idx ON bundles(fingerprint_hash);
+CREATE INDEX bundles_channel_idx ON bundles(channel);
+CREATE INDEX bundles_rollout_idx ON bundles(rollout_cohort_count);
+CREATE INDEX bundles_target_cohorts_idx ON bundles USING GIN (target_cohorts);
+CREATE INDEX bundle_patches_bundle_id_idx ON bundle_patches(bundle_id);
+CREATE INDEX bundle_patches_base_bundle_id_idx ON bundle_patches(base_bundle_id);

package/dart-src/plugins/postgres/sql/get_target_app_version_list.sql

@@ -0,0 +1,21 @@
+-- HotUpdater.get_target_app_version_list
+
+CREATE OR REPLACE FUNCTION get_target_app_version_list (
+    app_platform platforms,
+    min_bundle_id uuid
+)
+RETURNS TABLE (
+    target_app_version text
+)
+LANGUAGE plpgsql
+AS
+$$
+BEGIN
+    RETURN QUERY
+    SELECT b.target_app_version
+    FROM bundles b 
+    WHERE b.platform = app_platform
+    AND b.id >= min_bundle_id
+    GROUP BY b.target_app_version;
+END;
+$$;

package/dart-src/plugins/postgres/sql/get_update_info.spec.ts

@@ -0,0 +1,171 @@
+import { PGlite } from "@electric-sql/pglite";
+import {
+  type Bundle,
+  type GetBundlesArgs,
+  NIL_UUID,
+  type UpdateInfo,
+} from "@hot-updater/core";
+import { filterCompatibleAppVersions } from "@hot-updater/js";
+import { setupGetUpdateInfoTestSuite } from "@hot-updater/test-utils";
+import camelcaseKeys from "camelcase-keys";
+import { afterAll, beforeEach, describe } from "vitest";
+
+import { prepareSql } from "./prepareSql";
+
+const createInsertBundleQuery = (bundle: Bundle) => {
+  const rolloutCohortCount = bundle.rolloutCohortCount ?? 1000;
+  const targetCohorts = bundle.targetCohorts
+    ? `ARRAY[${bundle.targetCohorts.map((id) => `'${id}'`).join(",")}]::TEXT[]`
+    : "NULL";
+
+  return `
+    INSERT INTO bundles (
+      id, file_hash, platform, target_app_version,
+      should_force_update, enabled, git_commit_hash, message, channel, storage_uri, fingerprint_hash,
+      rollout_cohort_count, target_cohorts
+    ) VALUES (
+      '${bundle.id}',
+      '${bundle.fileHash}',
+      '${bundle.platform}',
+      ${bundle.targetAppVersion ? `'${bundle.targetAppVersion}'` : "null"},
+      ${bundle.shouldForceUpdate},
+      ${bundle.enabled},
+      ${bundle.gitCommitHash ? `'${bundle.gitCommitHash}'` : "null"},
+      ${bundle.message ? `'${bundle.message}'` : "null"},
+      '${bundle.channel}',
+      '${bundle.storageUri}',
+      ${bundle.fingerprintHash ? `'${bundle.fingerprintHash}'` : "null"},
+      ${rolloutCohortCount},
+      ${targetCohorts}
+    ) ON CONFLICT (id) DO UPDATE SET
+      file_hash = EXCLUDED.file_hash,
+      platform = EXCLUDED.platform,
+      target_app_version = EXCLUDED.target_app_version,
+      should_force_update = EXCLUDED.should_force_update,
+      enabled = EXCLUDED.enabled,
+      git_commit_hash = EXCLUDED.git_commit_hash,
+      message = EXCLUDED.message,
+      channel = EXCLUDED.channel,
+      storage_uri = EXCLUDED.storage_uri,
+      fingerprint_hash = EXCLUDED.fingerprint_hash,
+      rollout_cohort_count = EXCLUDED.rollout_cohort_count,
+      target_cohorts = EXCLUDED.target_cohorts;
+  `;
+};
+
+const createGetUpdateInfo =
+  (db: PGlite) =>
+  async (
+    bundles: Bundle[],
+    args: GetBundlesArgs,
+  ): Promise<UpdateInfo | null> => {
+    const {
+      bundleId,
+      platform,
+      minBundleId = NIL_UUID,
+      channel = "production",
+      _updateStrategy,
+    } = args;
+    await db.exec(createInsertBundleQuerys(bundles));
+
+    if (_updateStrategy === "fingerprint") {
+      const fingerprintHash = args.fingerprintHash;
+      const cohort = args.cohort;
+      const cohortSql = cohort ? `'${cohort}'` : "NULL";
+      const result = await db.query<{
+        id: string;
+        should_force_update: boolean;
+        message: string;
+        status: string;
+        storage_uri: string | null;
+        file_hash: string | null;
+      }>(
+        `
+      SELECT * FROM get_update_info_by_fingerprint_hash(
+        '${platform}',
+        '${bundleId}',
+        '${minBundleId}',
+        '${channel}',
+        '${fingerprintHash}',
+        ${cohortSql}
+      );
+      `,
+      );
+
+      if (!result.rows[0]) {
+        return null;
+      }
+
+      const row = result.rows[0];
+      return camelcaseKeys(row) as UpdateInfo;
+    }
+
+    const appVersion = args.appVersion;
+    const { rows: appVersionList } = await db.query<{
+      target_app_version: string;
+    }>(
+      `
+      SELECT target_app_version FROM get_target_app_version_list('${platform}', '${minBundleId}');
+      `,
+    );
+
+    const targetAppVersionList = filterCompatibleAppVersions(
+      appVersionList?.map((group) => group.target_app_version) ?? [],
+      appVersion,
+    );
+
+    const cohort = args.cohort;
+    const cohortSql = cohort ? `'${cohort}'` : "NULL";
+    const result = await db.query<{
+      id: string;
+      should_force_update: boolean;
+      message: string;
+      status: string;
+      storage_uri: string | null;
+      file_hash: string | null;
+    }>(
+      `
+      SELECT * FROM get_update_info_by_app_version(
+        '${platform}',
+        '${appVersion}',
+        '${bundleId}',
+        '${minBundleId ?? NIL_UUID}',
+        '${channel}',
+        ARRAY[${targetAppVersionList.map((v) => `'${v}'`).join(",")}]::text[],
+        ${cohortSql}
+      );
+      `,
+    );
+
+    if (!result.rows[0]) {
+      return null;
+    }
+
+    const row = result.rows[0];
+    return camelcaseKeys(row) as UpdateInfo;
+  };
+
+const createInsertBundleQuerys = (bundles: Bundle[]) => {
+  return bundles.map(createInsertBundleQuery).join("\n");
+};
+
+const db = new PGlite();
+
+const sql = await prepareSql();
+await db.exec(sql);
+const getUpdateInfo = createGetUpdateInfo(db);
+
+describe("getUpdateInfo", () => {
+  beforeEach(async () => {
+    await db.exec("DELETE FROM bundle_patches");
+    await db.exec("DELETE FROM bundles");
+  });
+
+  afterAll(async () => {
+    await db.close();
+  });
+
+  setupGetUpdateInfoTestSuite({
+    getUpdateInfo: getUpdateInfo,
+  });
+});