@hot-updater/supabase 0.28.0 → 0.29.0

package/supabase/migrations/20260401000000_hot-updater_0.29.0.sql

@@ -0,0 +1,503 @@
+-- HotUpdater.bundles
+
+ALTER TABLE bundles
+  ADD COLUMN IF NOT EXISTS rollout_cohort_count INTEGER DEFAULT 1000
+    CHECK (rollout_cohort_count >= 0 AND rollout_cohort_count <= 1000);
+
+CREATE INDEX IF NOT EXISTS bundles_rollout_idx ON bundles(rollout_cohort_count);
+
+ALTER TABLE bundles
+  ADD COLUMN IF NOT EXISTS target_cohorts TEXT[];
+
+CREATE INDEX IF NOT EXISTS bundles_target_cohorts_idx ON bundles
+  USING GIN (target_cohorts);
+
+-- 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 THEN
+    RETURN normalized_cohort IS NOT NULL
+       AND normalized_cohort = ANY(normalized_target_cohorts);
+  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;
+$$;
+
+-- 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;
+$$;
+
+-- 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/dist/index.d.ts

@@ -1,22 +0,0 @@
-import * as _hot_updater_plugin_core1 from "@hot-updater/plugin-core";
-
-//#region src/supabaseDatabase.d.ts
-interface SupabaseDatabaseConfig {
-  supabaseUrl: string;
-  supabaseAnonKey: string;
-}
-declare const supabaseDatabase: (config: SupabaseDatabaseConfig, hooks?: _hot_updater_plugin_core1.DatabasePluginHooks) => (() => _hot_updater_plugin_core1.DatabasePlugin);
-//#endregion
-//#region src/supabaseStorage.d.ts
-interface SupabaseStorageConfig {
-  supabaseUrl: string;
-  supabaseAnonKey: string;
-  bucketName: string;
-  /**
-   * Base path where bundles will be stored in the bucket
-   */
-  basePath?: string;
-}
-declare const supabaseStorage: (config: SupabaseStorageConfig, hooks?: _hot_updater_plugin_core1.StoragePluginHooks) => () => _hot_updater_plugin_core1.StoragePlugin;
-//#endregion
-export { SupabaseDatabaseConfig, SupabaseStorageConfig, supabaseDatabase, supabaseStorage };

package/dist/index.js

@@ -1,145 +0,0 @@
-import { calculatePagination, createDatabasePlugin, createStorageKeyBuilder, createStoragePlugin, getContentType, parseStorageUri } from "@hot-updater/plugin-core";
-import { createClient } from "@supabase/supabase-js";
-import fs from "fs/promises";
-import path from "path";
-
-//#region src/supabaseDatabase.ts
-const supabaseDatabase = createDatabasePlugin({
-	name: "supabaseDatabase",
-	factory: (config) => {
-		const supabase = createClient(config.supabaseUrl, config.supabaseAnonKey);
-		return {
-			async getBundleById(bundleId) {
-				const { data, error } = await supabase.from("bundles").select("channel, enabled, should_force_update, file_hash, git_commit_hash, id, message, platform, target_app_version, fingerprint_hash, storage_uri, metadata").eq("id", bundleId).single();
-				if (!data || error) return null;
-				return {
-					channel: data.channel,
-					enabled: data.enabled,
-					shouldForceUpdate: data.should_force_update,
-					fileHash: data.file_hash,
-					gitCommitHash: data.git_commit_hash,
-					id: data.id,
-					message: data.message,
-					platform: data.platform,
-					targetAppVersion: data.target_app_version,
-					fingerprintHash: data.fingerprint_hash,
-					storageUri: data.storage_uri,
-					metadata: data.metadata ?? {}
-				};
-			},
-			async getBundles(options) {
-				const { where, limit, offset } = options ?? {};
-				let countQuery = supabase.from("bundles").select("*", {
-					count: "exact",
-					head: true
-				});
-				if (where?.channel) countQuery = countQuery.eq("channel", where.channel);
-				if (where?.platform) countQuery = countQuery.eq("platform", where.platform);
-				const { count: total = 0 } = await countQuery;
-				let query = supabase.from("bundles").select("id, channel, enabled, platform, should_force_update, file_hash, git_commit_hash, message, fingerprint_hash, target_app_version, storage_uri, metadata").order("id", { ascending: false });
-				if (where?.channel) query = query.eq("channel", where.channel);
-				if (where?.platform) query = query.eq("platform", where.platform);
-				if (limit) query = query.limit(limit);
-				if (offset) query = query.range(offset, offset + (limit || 20) - 1);
-				const { data } = await query;
-				return {
-					data: data ? data.map((bundle) => ({
-						channel: bundle.channel,
-						enabled: bundle.enabled,
-						shouldForceUpdate: bundle.should_force_update,
-						fileHash: bundle.file_hash,
-						gitCommitHash: bundle.git_commit_hash,
-						id: bundle.id,
-						message: bundle.message,
-						platform: bundle.platform,
-						targetAppVersion: bundle.target_app_version,
-						fingerprintHash: bundle.fingerprint_hash,
-						storageUri: bundle.storage_uri,
-						metadata: bundle.metadata ?? {}
-					})) : [],
-					pagination: calculatePagination(total ?? 0, {
-						limit,
-						offset
-					})
-				};
-			},
-			async getChannels() {
-				const { data, error } = await supabase.rpc("get_channels");
-				if (error) throw error;
-				return data.map((bundle) => bundle.channel);
-			},
-			async commitBundle({ changedSets }) {
-				if (changedSets.length === 0) return;
-				for (const op of changedSets) if (op.operation === "delete") {
-					const { error } = await supabase.from("bundles").delete().eq("id", op.data.id);
-					if (error) throw new Error(`Failed to delete bundle: ${error.message}`);
-				} else if (op.operation === "insert" || op.operation === "update") {
-					const bundle = op.data;
-					const { error } = await supabase.from("bundles").upsert({
-						id: bundle.id,
-						channel: bundle.channel,
-						enabled: bundle.enabled,
-						should_force_update: bundle.shouldForceUpdate,
-						file_hash: bundle.fileHash,
-						git_commit_hash: bundle.gitCommitHash,
-						message: bundle.message,
-						platform: bundle.platform,
-						target_app_version: bundle.targetAppVersion,
-						fingerprint_hash: bundle.fingerprintHash,
-						storage_uri: bundle.storageUri,
-						metadata: bundle.metadata
-					}, { onConflict: "id" });
-					if (error) throw error;
-				}
-			}
-		};
-	}
-});
-
-//#endregion
-//#region src/supabaseStorage.ts
-const supabaseStorage = createStoragePlugin({
-	name: "supabaseStorage",
-	supportedProtocol: "supabase-storage",
-	factory: (config) => {
-		const bucket = createClient(config.supabaseUrl, config.supabaseAnonKey).storage.from(config.bucketName);
-		const getStorageKey = createStorageKeyBuilder(config.basePath);
-		return {
-			async delete(storageUri) {
-				const { key, bucket: bucketName } = parseStorageUri(storageUri, "supabase-storage");
-				if (bucketName !== config.bucketName) throw new Error(`Bucket name mismatch: expected "${config.bucketName}", but found "${bucketName}".`);
-				const { error } = await bucket.remove([key]);
-				if (error) {
-					if (error.message?.includes("not found")) throw new Error(`Bundle not found`);
-					throw new Error(`Failed to delete bundle: ${error.message}`);
-				}
-			},
-			async upload(key, filePath) {
-				const Body = await fs.readFile(filePath);
-				const ContentType = getContentType(filePath);
-				const Key = getStorageKey(key, path.basename(filePath));
-				const upload = await bucket.upload(Key, Body, {
-					contentType: ContentType,
-					cacheControl: "max-age=31536000",
-					headers: {}
-				});
-				if (upload.error) throw upload.error;
-				return { storageUri: `supabase-storage://${upload.data.fullPath}` };
-			},
-			async getDownloadUrl(storageUri) {
-				const u = new URL(storageUri);
-				if (u.protocol.replace(":", "") !== "supabase-storage") throw new Error("Invalid Supabase storage URI protocol");
-				let key = `${u.host}${u.pathname}`.replace(/^\//, "");
-				if (!key) throw new Error("Invalid Supabase storage URI: missing key");
-				if (key.startsWith(`${config.bucketName}/`)) key = key.substring(`${config.bucketName}/`.length);
-				const { data, error } = await bucket.createSignedUrl(key, 3600);
-				if (error) throw new Error(`Failed to generate download URL: ${error.message}`);
-				if (!data?.signedUrl) throw new Error("Failed to generate download URL");
-				return { fileUrl: data.signedUrl };
-			}
-		};
-	}
-});
-
-//#endregion
-export { supabaseDatabase, supabaseStorage };