@_nazmiforreal/flutter-ota 0.1.0 → 0.1.2

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

@@ -0,0 +1,126 @@
+-- HotUpdater.get_update_info_by_app_version
+
+DROP FUNCTION IF EXISTS get_update_info_by_app_version;
+
+CREATE OR REPLACE FUNCTION get_update_info_by_app_version (
+    app_platform   platforms,
+    app_version text,
+    bundle_id  uuid,
+    min_bundle_id uuid,
+    target_channel text,
+    target_app_version_list text[],
+    cohort TEXT DEFAULT NULL
+)
+RETURNS TABLE (
+    id            uuid,
+    should_force_update  boolean,
+    message       text,
+    status        text,
+    storage_uri   text,
+    file_hash     text
+)
+LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    NIL_UUID CONSTANT uuid := '00000000-0000-0000-0000-000000000000';
+BEGIN
+    RETURN QUERY
+    WITH candidate_bundles AS (
+        SELECT
+            b.id,
+            b.should_force_update,
+            b.message,
+            b.storage_uri,
+            b.file_hash,
+            b.rollout_cohort_count,
+            b.target_cohorts
+        FROM bundles b
+        WHERE b.enabled = TRUE
+          AND b.platform = app_platform
+          AND b.id >= min_bundle_id
+          AND b.target_app_version IN (SELECT unnest(target_app_version_list))
+          AND b.channel = target_channel
+    ),
+    current_candidate AS (
+        SELECT
+            cb.id,
+            is_cohort_eligible(
+                cb.id,
+                cohort,
+                cb.rollout_cohort_count,
+                cb.target_cohorts
+            ) AS is_eligible
+        FROM candidate_bundles cb
+        WHERE cb.id = bundle_id
+        LIMIT 1
+    ),
+    eligible_update_candidate AS (
+        SELECT
+            cb.id,
+            cb.should_force_update,
+            cb.message,
+            'UPDATE' AS status,
+            cb.storage_uri,
+            cb.file_hash
+        FROM candidate_bundles cb
+        WHERE cb.id > bundle_id
+          AND is_cohort_eligible(
+              cb.id,
+              cohort,
+              cb.rollout_cohort_count,
+              cb.target_cohorts
+          )
+        ORDER BY cb.id DESC
+        LIMIT 1
+    ),
+    rollback_candidate AS (
+        SELECT
+            cb.id,
+            TRUE AS should_force_update,
+            cb.message,
+            'ROLLBACK' AS status,
+            cb.storage_uri,
+            cb.file_hash
+        FROM candidate_bundles cb
+        WHERE cb.id < bundle_id
+          AND NOT EXISTS (
+              SELECT 1
+              FROM current_candidate
+              WHERE current_candidate.is_eligible = TRUE
+          )
+          AND NOT EXISTS (SELECT 1 FROM eligible_update_candidate)
+        ORDER BY cb.id DESC
+        LIMIT 1
+    ),
+    final_result AS (
+        SELECT * FROM eligible_update_candidate
+        UNION ALL
+        SELECT * FROM rollback_candidate
+        WHERE NOT EXISTS (SELECT 1 FROM eligible_update_candidate)
+    )
+    SELECT *
+    FROM final_result
+    WHERE final_result.id != bundle_id
+
+    UNION ALL
+
+    SELECT
+        NIL_UUID      AS id,
+        TRUE          AS should_force_update,
+        NULL          AS message,
+        'ROLLBACK'    AS status,
+        NULL          AS storage_uri,
+        NULL          AS file_hash
+    WHERE (SELECT COUNT(*) FROM final_result) = 0
+      AND bundle_id != NIL_UUID
+      AND bundle_id > min_bundle_id
+      AND NOT EXISTS (
+          SELECT 1
+          FROM current_candidate
+          WHERE current_candidate.is_eligible = TRUE
+      )
+      AND NOT EXISTS (SELECT 1 FROM eligible_update_candidate)
+      AND NOT EXISTS (SELECT 1 FROM rollback_candidate);
+END;
+$$;

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

@@ -0,0 +1,125 @@
+-- HotUpdater.get_update_info_by_fingerprint_hash
+
+DROP FUNCTION IF EXISTS get_update_info_by_fingerprint_hash;
+
+CREATE OR REPLACE FUNCTION get_update_info_by_fingerprint_hash (
+    app_platform   platforms,
+    bundle_id  uuid,
+    min_bundle_id uuid,
+    target_channel text,
+    target_fingerprint_hash text,
+    cohort TEXT DEFAULT NULL
+)
+RETURNS TABLE (
+    id            uuid,
+    should_force_update  boolean,
+    message       text,
+    status        text,
+    storage_uri   text,
+    file_hash     text
+)
+LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    NIL_UUID CONSTANT uuid := '00000000-0000-0000-0000-000000000000';
+BEGIN
+    RETURN QUERY
+    WITH candidate_bundles AS (
+        SELECT
+            b.id,
+            b.should_force_update,
+            b.message,
+            b.storage_uri,
+            b.file_hash,
+            b.rollout_cohort_count,
+            b.target_cohorts
+        FROM bundles b
+        WHERE b.enabled = TRUE
+          AND b.platform = app_platform
+          AND b.id >= min_bundle_id
+          AND b.channel = target_channel
+          AND b.fingerprint_hash = target_fingerprint_hash
+    ),
+    current_candidate AS (
+        SELECT
+            cb.id,
+            is_cohort_eligible(
+                cb.id,
+                cohort,
+                cb.rollout_cohort_count,
+                cb.target_cohorts
+            ) AS is_eligible
+        FROM candidate_bundles cb
+        WHERE cb.id = bundle_id
+        LIMIT 1
+    ),
+    eligible_update_candidate AS (
+        SELECT
+            cb.id,
+            cb.should_force_update,
+            cb.message,
+            'UPDATE' AS status,
+            cb.storage_uri,
+            cb.file_hash
+        FROM candidate_bundles cb
+        WHERE cb.id > bundle_id
+          AND is_cohort_eligible(
+              cb.id,
+              cohort,
+              cb.rollout_cohort_count,
+              cb.target_cohorts
+          )
+        ORDER BY cb.id DESC
+        LIMIT 1
+    ),
+    rollback_candidate AS (
+        SELECT
+            cb.id,
+            TRUE AS should_force_update,
+            cb.message,
+            'ROLLBACK' AS status,
+            cb.storage_uri,
+            cb.file_hash
+        FROM candidate_bundles cb
+        WHERE cb.id < bundle_id
+          AND NOT EXISTS (
+              SELECT 1
+              FROM current_candidate
+              WHERE current_candidate.is_eligible = TRUE
+          )
+          AND NOT EXISTS (SELECT 1 FROM eligible_update_candidate)
+        ORDER BY cb.id DESC
+        LIMIT 1
+    ),
+    final_result AS (
+        SELECT * FROM eligible_update_candidate
+        UNION ALL
+        SELECT * FROM rollback_candidate
+        WHERE NOT EXISTS (SELECT 1 FROM eligible_update_candidate)
+    )
+    SELECT *
+    FROM final_result
+    WHERE final_result.id != bundle_id
+
+    UNION ALL
+
+    SELECT
+        NIL_UUID      AS id,
+        TRUE          AS should_force_update,
+        NULL          AS message,
+        'ROLLBACK'    AS status,
+        NULL          AS storage_uri,
+        NULL          AS file_hash
+    WHERE (SELECT COUNT(*) FROM final_result) = 0
+      AND bundle_id != NIL_UUID
+      AND bundle_id > min_bundle_id
+      AND NOT EXISTS (
+          SELECT 1
+          FROM current_candidate
+          WHERE current_candidate.is_eligible = TRUE
+      )
+      AND NOT EXISTS (SELECT 1 FROM eligible_update_candidate)
+      AND NOT EXISTS (SELECT 1 FROM rollback_candidate);
+END;
+$$;

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

@@ -0,0 +1,30 @@
+-- Deterministic hash function matching JavaScript implementation
+-- Returns hash value in range [0, 99]
+CREATE OR REPLACE FUNCTION hash_user_id(user_id TEXT)
+RETURNS INTEGER
+LANGUAGE plpgsql
+IMMUTABLE
+AS $$
+DECLARE
+  hash BIGINT := 0;
+  char_code INTEGER;
+  i INTEGER;
+  normalized BIGINT;
+BEGIN
+  -- Replicate JavaScript hash algorithm
+  FOR i IN 1..length(user_id) LOOP
+    char_code := ascii(substring(user_id from i for 1));
+    hash := (hash * 31) + char_code;
+
+    -- Simulate JavaScript's |= 0 by wrapping into a signed 32-bit range.
+    normalized := mod(hash + 2147483648, 4294967296);
+    IF normalized < 0 THEN
+      normalized := normalized + 4294967296;
+    END IF;
+    hash := normalized - 2147483648;
+  END LOOP;
+
+  -- Return absolute value modulo 100
+  RETURN abs(hash % 100);
+END;
+$$;

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

@@ -0,0 +1,237 @@
+-- HotUpdater.is_cohort_eligible
+-- Cohort eligibility helpers matching @hot-updater/core rollout.ts
+
+CREATE OR REPLACE FUNCTION positive_mod(
+  value INTEGER,
+  modulus INTEGER
+)
+RETURNS INTEGER
+LANGUAGE plpgsql
+IMMUTABLE
+AS $$
+BEGIN
+  RETURN ((value % modulus) + modulus) % modulus;
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION hash_rollout_value(input TEXT)
+RETURNS INTEGER
+LANGUAGE plpgsql
+IMMUTABLE
+AS $$
+DECLARE
+  hash_value NUMERIC := 0;
+  char_code INTEGER;
+  i INTEGER;
+BEGIN
+  FOR i IN 1..length(input) LOOP
+    char_code := ascii(substring(input from i for 1));
+    hash_value := mod((hash_value * 31) + char_code, 4294967296);
+  END LOOP;
+
+  IF hash_value >= 2147483648 THEN
+    hash_value := hash_value - 4294967296;
+  END IF;
+
+  RETURN hash_value::INTEGER;
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION normalize_cohort_value(cohort TEXT)
+RETURNS TEXT
+LANGUAGE plpgsql
+IMMUTABLE
+AS $$
+DECLARE
+  normalized TEXT;
+  cohort_value INTEGER;
+BEGIN
+  IF cohort IS NULL THEN
+    RETURN NULL;
+  END IF;
+
+  normalized := lower(btrim(cohort));
+
+  IF normalized ~ '^[0-9]+$' THEN
+    cohort_value := normalized::INTEGER;
+    IF cohort_value BETWEEN 1 AND 1000 THEN
+      RETURN cohort_value::TEXT;
+    END IF;
+  END IF;
+
+  RETURN normalized;
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION gcd_int(a INTEGER, b INTEGER)
+RETURNS INTEGER
+LANGUAGE plpgsql
+IMMUTABLE
+AS $$
+DECLARE
+  x INTEGER := abs(a);
+  y INTEGER := abs(b);
+  next_value INTEGER;
+BEGIN
+  WHILE y <> 0 LOOP
+    next_value := x % y;
+    x := y;
+    y := next_value;
+  END LOOP;
+
+  RETURN x;
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION get_rollout_multiplier(bundle_id UUID)
+RETURNS INTEGER
+LANGUAGE plpgsql
+IMMUTABLE
+AS $$
+DECLARE
+  candidate INTEGER := positive_mod(
+    hash_rollout_value(bundle_id::TEXT || ':multiplier'),
+    997
+  );
+BEGIN
+  IF candidate = 0 THEN
+    candidate := 1;
+  END IF;
+
+  WHILE gcd_int(candidate, 1000) <> 1 LOOP
+    candidate := positive_mod(candidate + 1, 1000);
+    IF candidate = 0 THEN
+      candidate := 1;
+    END IF;
+  END LOOP;
+
+  RETURN candidate;
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION get_rollout_offset(bundle_id UUID)
+RETURNS INTEGER
+LANGUAGE plpgsql
+IMMUTABLE
+AS $$
+BEGIN
+  RETURN positive_mod(hash_rollout_value(bundle_id::TEXT || ':offset'), 1000);
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION get_modular_inverse(value INTEGER, modulus INTEGER)
+RETURNS INTEGER
+LANGUAGE plpgsql
+IMMUTABLE
+AS $$
+DECLARE
+  candidate INTEGER;
+BEGIN
+  FOR candidate IN 1..(modulus - 1) LOOP
+    IF positive_mod(value * candidate, modulus) = 1 THEN
+      RETURN candidate;
+    END IF;
+  END LOOP;
+
+  RAISE EXCEPTION 'No modular inverse for % mod %', value, modulus;
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION is_numeric_cohort(cohort TEXT)
+RETURNS BOOLEAN
+LANGUAGE plpgsql
+IMMUTABLE
+AS $$
+DECLARE
+  normalized_cohort TEXT := normalize_cohort_value(cohort);
+  cohort_value INTEGER;
+BEGIN
+  IF normalized_cohort IS NULL OR normalized_cohort !~ '^[0-9]+$' THEN
+    RETURN FALSE;
+  END IF;
+
+  cohort_value := normalized_cohort::INTEGER;
+  RETURN cohort_value BETWEEN 1 AND 1000;
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION get_numeric_cohort_rollout_position(
+  bundle_id UUID,
+  cohort TEXT
+)
+RETURNS INTEGER
+LANGUAGE plpgsql
+IMMUTABLE
+AS $$
+DECLARE
+  normalized_cohort TEXT := normalize_cohort_value(cohort);
+  cohort_value INTEGER;
+  multiplier INTEGER;
+  offset_value INTEGER;
+  inverse_multiplier INTEGER;
+BEGIN
+  IF NOT is_numeric_cohort(normalized_cohort) THEN
+    RAISE EXCEPTION 'Invalid numeric cohort: %', cohort;
+  END IF;
+
+  cohort_value := normalized_cohort::INTEGER - 1;
+  multiplier := get_rollout_multiplier(bundle_id);
+  offset_value := get_rollout_offset(bundle_id);
+  inverse_multiplier := get_modular_inverse(multiplier, 1000);
+
+  RETURN positive_mod(
+    inverse_multiplier * (cohort_value - offset_value),
+    1000
+  );
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION is_cohort_eligible(
+  bundle_id UUID,
+  cohort TEXT,
+  rollout_cohort_count INTEGER,
+  target_cohorts TEXT[]
+)
+RETURNS BOOLEAN
+LANGUAGE plpgsql
+IMMUTABLE
+AS $$
+DECLARE
+  normalized_cohort TEXT := normalize_cohort_value(cohort);
+  normalized_rollout_count INTEGER := COALESCE(rollout_cohort_count, 1000);
+  normalized_target_cohorts TEXT[];
+BEGIN
+  IF target_cohorts IS NOT NULL THEN
+    normalized_target_cohorts := ARRAY(
+      SELECT normalize_cohort_value(value)
+      FROM unnest(target_cohorts) AS value
+    );
+  END IF;
+
+  IF normalized_target_cohorts IS NOT NULL
+     AND array_length(normalized_target_cohorts, 1) > 0
+     AND normalized_cohort IS NOT NULL
+     AND normalized_cohort = ANY(normalized_target_cohorts) THEN
+    RETURN TRUE;
+  END IF;
+
+  IF normalized_rollout_count <= 0 THEN
+    RETURN FALSE;
+  END IF;
+
+  IF normalized_cohort IS NULL THEN
+    RETURN normalized_rollout_count >= 1000;
+  END IF;
+
+  IF NOT is_numeric_cohort(normalized_cohort) THEN
+    RETURN FALSE;
+  END IF;
+
+  IF normalized_rollout_count >= 1000 THEN
+    RETURN TRUE;
+  END IF;
+
+  RETURN get_numeric_cohort_rollout_position(bundle_id, normalized_cohort)
+    < normalized_rollout_count;
+END;
+$$;

package/dart-src/plugins/postgres/sql/prepareSql.ts

@@ -0,0 +1,11 @@
+import fs from "fs/promises";
+import path from "path";
+
+export const prepareSql = async () => {
+  const files = await fs.readdir(__dirname);
+  const sqlFiles = files.filter((file) => file.endsWith(".sql"));
+  const contents = await Promise.all(
+    sqlFiles.map((file) => fs.readFile(path.join(__dirname, file), "utf-8")),
+  );
+  return contents.join("\n");
+};

package/dart-src/plugins/standalone/lib/flutter_patcher_standalone.dart

@@ -0,0 +1,12 @@
+export 'src/standalone_config.dart'
+    show
+        StandaloneClientFactory,
+        StandaloneRepositoryConfig,
+        StandaloneRepositoryRoutes,
+        StandaloneStorageConfig,
+        StandaloneStorageRoutes,
+        buildPath,
+        joinUrl,
+        mergeHeaders;
+export 'src/standalone_database.dart' show standaloneRepository;
+export 'src/standalone_storage.dart' show standaloneStorage;

package/dart-src/plugins/standalone/lib/src/standalone_config.dart

@@ -0,0 +1,107 @@
+import 'dart:convert' show jsonEncode;
+
+import 'package:http/http.dart' as http;
+import 'package:http/http.dart';
+
+/// A factory that returns the [http.Client] used by standalone plugins.
+///
+/// Injectable so tests can supply a mock client.
+typedef StandaloneClientFactory = Client Function();
+
+/// Configuration for the standalone repository (the database half of the
+/// self-hosted backend).
+class StandaloneRepositoryConfig {
+  const StandaloneRepositoryConfig({
+    required this.baseUrl,
+    this.commonHeaders,
+    this.routes,
+    this.clientFactory,
+  });
+
+  final String baseUrl;
+  final Map<String, String>? commonHeaders;
+  final StandaloneRepositoryRoutes? routes;
+  final StandaloneClientFactory? clientFactory;
+}
+
+/// Overridable route templates for the repository REST contract.
+class StandaloneRepositoryRoutes {
+  const StandaloneRepositoryRoutes({
+    this.create = '/api/bundles',
+    this.list = '/api/bundles',
+    this.channels = '/api/bundles/channels',
+    this.retrieve = '/api/bundles/:id',
+    this.update = '/api/bundles/:id',
+    this.delete = '/api/bundles/:id',
+  });
+
+  final String create;
+  final String list;
+  final String channels;
+  final String retrieve;
+  final String update;
+  final String delete;
+}
+
+/// Configuration for the standalone storage (the storage half of the
+/// self-hosted backend).
+class StandaloneStorageConfig {
+  const StandaloneStorageConfig({
+    required this.baseUrl,
+    this.commonHeaders,
+    this.routes,
+    this.clientFactory,
+  });
+
+  final String baseUrl;
+  final Map<String, String>? commonHeaders;
+  final StandaloneStorageRoutes? routes;
+  final StandaloneClientFactory? clientFactory;
+}
+
+/// Overridable route templates for the storage REST contract.
+class StandaloneStorageRoutes {
+  const StandaloneStorageRoutes({
+    this.upload = '/api/upload',
+    this.getDownloadUrl = '/api/getDownloadUrl',
+    this.delete = '/api/delete',
+    this.readText = '/api/readText',
+    this.list = '/api/list',
+    this.serveFile = '/api/_file',
+  });
+
+  final String upload;
+  final String getDownloadUrl;
+  final String delete;
+  final String readText;
+  final String list;
+  final String serveFile;
+}
+
+/// Build a request path from a route template that may contain `:id`.
+String buildPath(String template, {String? id}) {
+  var path = template;
+  if (id != null) path = path.replaceAll(':id', id);
+  return path;
+}
+
+/// Join [baseUrl] and [path], ensuring exactly one `/` between them.
+String joinUrl(String baseUrl, String path) {
+  final base = baseUrl.endsWith('/') ? baseUrl.substring(0, baseUrl.length - 1) : baseUrl;
+  final p = path.startsWith('/') ? path : '/$path';
+  return '$base$p';
+}
+
+/// Merge [commonHeaders] with extra per-request headers.
+Map<String, String> mergeHeaders(
+  Map<String, String>? common,
+  Map<String, String>? extra,
+) {
+  final result = <String, String>{};
+  if (common != null) result.addAll(common);
+  if (extra != null) result.addAll(extra);
+  return result;
+}
+
+/// Envelope helper: standalone create expects `[bundle]`.
+String encodeBundleList(Map<String, dynamic> bundle) => jsonEncode([bundle]);