@hot-updater/supabase 0.36.6 → 1.0.0-rc.0

package/dist/supabaseEdgeFunctionStorage-pV0s_mTF.mjs

@@ -1,356 +0,0 @@
-import { DEFAULT_ROLLOUT_COHORT_COUNT, NIL_UUID, getAssetBaseStorageUri, getBundlePatches, getManifestFileHash, getManifestStorageUri, stripBundleArtifactMetadata } from "@hot-updater/core";
-import { calculatePagination, createDatabasePlugin, createRuntimeStoragePlugin, filterCompatibleAppVersions, parseStorageUri } from "@hot-updater/plugin-core";
-import { createClient } from "@supabase/supabase-js";
-//#region src/supabaseBundleMapper.ts
-const BUNDLE_SELECT_COLUMNS = "id, channel, enabled, platform, should_force_update, file_hash, git_commit_hash, message, fingerprint_hash, target_app_version, storage_uri, metadata, manifest_storage_uri, manifest_file_hash, asset_base_storage_uri, rollout_cohort_count, target_cohorts";
-const normalizeMetadata = (value) => {
-	if (!value) return {};
-	if (typeof value === "string") try {
-		return normalizeMetadata(JSON.parse(value));
-	} catch {
-		return {};
-	}
-	if (typeof value === "object" && !Array.isArray(value)) return value;
-	return {};
-};
-const buildBundlePatchId = (bundleId, baseBundleId) => `${bundleId}:${baseBundleId}`;
-const mapRowToBundle = (row, patchRows = []) => {
-	const rawMetadata = normalizeMetadata(row.metadata);
-	const patches = patchRows.slice().sort((left, right) => left.order_index - right.order_index || left.base_bundle_id.localeCompare(right.base_bundle_id)).map((patch) => ({
-		baseBundleId: patch.base_bundle_id,
-		baseFileHash: patch.base_file_hash,
-		patchFileHash: patch.patch_file_hash,
-		patchStorageUri: patch.patch_storage_uri
-	}));
-	const primaryPatch = patches[0] ?? null;
-	return {
-		channel: row.channel,
-		enabled: Boolean(row.enabled),
-		shouldForceUpdate: Boolean(row.should_force_update),
-		fileHash: row.file_hash,
-		gitCommitHash: row.git_commit_hash,
-		id: row.id,
-		message: row.message,
-		platform: row.platform,
-		targetAppVersion: row.target_app_version,
-		fingerprintHash: row.fingerprint_hash,
-		storageUri: row.storage_uri,
-		metadata: stripBundleArtifactMetadata(rawMetadata),
-		manifestStorageUri: row.manifest_storage_uri ?? null,
-		manifestFileHash: row.manifest_file_hash ?? null,
-		assetBaseStorageUri: row.asset_base_storage_uri ?? null,
-		patches,
-		patchBaseBundleId: primaryPatch?.baseBundleId ?? null,
-		patchBaseFileHash: primaryPatch?.baseFileHash ?? null,
-		patchFileHash: primaryPatch?.patchFileHash ?? null,
-		patchStorageUri: primaryPatch?.patchStorageUri ?? null,
-		rolloutCohortCount: row.rollout_cohort_count ?? DEFAULT_ROLLOUT_COHORT_COUNT,
-		targetCohorts: row.target_cohorts ?? null
-	};
-};
-const bundleToRow = (bundle) => ({
-	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: stripBundleArtifactMetadata(bundle.metadata) ?? {},
-	manifest_storage_uri: getManifestStorageUri(bundle),
-	manifest_file_hash: getManifestFileHash(bundle),
-	asset_base_storage_uri: getAssetBaseStorageUri(bundle),
-	rollout_cohort_count: bundle.rolloutCohortCount ?? DEFAULT_ROLLOUT_COHORT_COUNT,
-	target_cohorts: bundle.targetCohorts ?? null
-});
-const bundleToPatchRows = (bundle) => getBundlePatches(bundle).map((patch, index) => ({
-	id: buildBundlePatchId(bundle.id, patch.baseBundleId),
-	bundle_id: bundle.id,
-	base_bundle_id: patch.baseBundleId,
-	base_file_hash: patch.baseFileHash,
-	patch_file_hash: patch.patchFileHash,
-	patch_storage_uri: patch.patchStorageUri,
-	order_index: index
-}));
-//#endregion
-//#region src/supabaseConfig.ts
-const resolveSupabaseServiceRoleKey = (config) => {
-	const key = config.supabaseServiceRoleKey ?? config.supabaseAnonKey;
-	if (!key) throw new Error("Supabase service role key is required. Set supabaseServiceRoleKey.");
-	return key;
-};
-//#endregion
-//#region src/supabaseDatabase.ts
-const createSupabaseError = (error) => {
-	if (error instanceof Error) return error;
-	if (error && typeof error === "object") {
-		const properties = {};
-		let target = error;
-		while (target && target !== Object.prototype) {
-			for (const key of Object.getOwnPropertyNames(target)) properties[key] = error[key];
-			target = Object.getPrototypeOf(target);
-		}
-		return new Error(JSON.stringify({
-			name: error.constructor.name,
-			...properties
-		}));
-	}
-	try {
-		return new Error(JSON.stringify(error));
-	} catch {
-		return new Error(String(error));
-	}
-};
-const mapUpdateInfoRow = (row) => ({
-	id: row.id,
-	shouldForceUpdate: row.should_force_update,
-	message: row.message,
-	status: row.status,
-	storageUri: row.storage_uri,
-	fileHash: row.file_hash
-});
-const supabaseDatabase = createDatabasePlugin({
-	name: "supabaseDatabase",
-	factory: (config) => {
-		const supabase = createClient(config.supabaseUrl, resolveSupabaseServiceRoleKey(config));
-		const fetchPatchMap = async (bundleIds) => {
-			const patchMap = /* @__PURE__ */ new Map();
-			if (bundleIds.length === 0) return patchMap;
-			const { data, error } = await supabase.from("bundle_patches").select("*").in("bundle_id", bundleIds).order("order_index", { ascending: true });
-			if (error) throw createSupabaseError(error);
-			for (const row of data ?? []) {
-				const current = patchMap.get(row.bundle_id) ?? [];
-				current.push(row);
-				patchMap.set(row.bundle_id, current);
-			}
-			return patchMap;
-		};
-		return {
-			async getUpdateInfo(args) {
-				const channel = args.channel ?? "production";
-				const minBundleId = args.minBundleId ?? NIL_UUID;
-				if (args._updateStrategy === "appVersion") {
-					const { data: targetAppVersionRows, error: targetAppVersionError } = await supabase.rpc("get_target_app_version_list", {
-						app_platform: args.platform,
-						min_bundle_id: minBundleId
-					});
-					if (targetAppVersionError) throw createSupabaseError(targetAppVersionError);
-					const targetAppVersionList = filterCompatibleAppVersions((targetAppVersionRows ?? []).map((row) => row.target_app_version).filter((version) => Boolean(version)), args.appVersion);
-					const { data, error } = await supabase.rpc("get_update_info_by_app_version", {
-						app_platform: args.platform,
-						app_version: args.appVersion,
-						bundle_id: args.bundleId,
-						min_bundle_id: minBundleId,
-						target_channel: channel,
-						target_app_version_list: targetAppVersionList,
-						cohort: args.cohort ?? null
-					});
-					if (error) throw createSupabaseError(error);
-					const updateInfo = data?.[0] ?? null;
-					return updateInfo ? mapUpdateInfoRow(updateInfo) : null;
-				}
-				const { data, error } = await supabase.rpc("get_update_info_by_fingerprint_hash", {
-					app_platform: args.platform,
-					bundle_id: args.bundleId,
-					min_bundle_id: minBundleId,
-					target_channel: channel,
-					target_fingerprint_hash: args.fingerprintHash,
-					cohort: args.cohort ?? null
-				});
-				if (error) throw createSupabaseError(error);
-				const updateInfo = data?.[0] ?? null;
-				return updateInfo ? mapUpdateInfoRow(updateInfo) : null;
-			},
-			async getBundleById(bundleId) {
-				const [{ data, error }, patchMap] = await Promise.all([supabase.from("bundles").select(BUNDLE_SELECT_COLUMNS).eq("id", bundleId).single(), fetchPatchMap([bundleId])]);
-				if (!data || error) return null;
-				return mapRowToBundle(data, patchMap.get(bundleId) ?? []);
-			},
-			async getBundles(options) {
-				const { where, limit, orderBy } = options ?? {};
-				const offset = (options && "offset" in options ? options.offset : void 0) ?? 0;
-				if (where?.targetAppVersionIn && where.targetAppVersionIn.length === 0 || where?.id?.in && where.id.in.length === 0) return {
-					data: [],
-					pagination: calculatePagination(0, {
-						limit,
-						offset
-					})
-				};
-				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);
-				if (where?.enabled !== void 0) countQuery = countQuery.eq("enabled", where.enabled);
-				if (where?.fingerprintHash !== void 0) countQuery = where.fingerprintHash === null ? countQuery.is("fingerprint_hash", null) : countQuery.eq("fingerprint_hash", where.fingerprintHash);
-				if (where?.targetAppVersion !== void 0) countQuery = where.targetAppVersion === null ? countQuery.is("target_app_version", null) : countQuery.eq("target_app_version", where.targetAppVersion);
-				if (where?.targetAppVersionIn) countQuery = countQuery.in("target_app_version", where.targetAppVersionIn);
-				if (where?.targetAppVersionNotNull) countQuery = countQuery.not("target_app_version", "is", null);
-				if (where?.id?.eq) countQuery = countQuery.eq("id", where.id.eq);
-				if (where?.id?.gt) countQuery = countQuery.gt("id", where.id.gt);
-				if (where?.id?.gte) countQuery = countQuery.gte("id", where.id.gte);
-				if (where?.id?.lt) countQuery = countQuery.lt("id", where.id.lt);
-				if (where?.id?.lte) countQuery = countQuery.lte("id", where.id.lte);
-				if (where?.id?.in) countQuery = countQuery.in("id", where.id.in);
-				const { count: total = 0 } = await countQuery;
-				let query = supabase.from("bundles").select(BUNDLE_SELECT_COLUMNS).order("id", { ascending: orderBy?.direction === "asc" });
-				if (where?.channel) query = query.eq("channel", where.channel);
-				if (where?.platform) query = query.eq("platform", where.platform);
-				if (where?.enabled !== void 0) query = query.eq("enabled", where.enabled);
-				if (where?.fingerprintHash !== void 0) query = where.fingerprintHash === null ? query.is("fingerprint_hash", null) : query.eq("fingerprint_hash", where.fingerprintHash);
-				if (where?.targetAppVersion !== void 0) query = where.targetAppVersion === null ? query.is("target_app_version", null) : query.eq("target_app_version", where.targetAppVersion);
-				if (where?.targetAppVersionIn) query = query.in("target_app_version", where.targetAppVersionIn);
-				if (where?.targetAppVersionNotNull) query = query.not("target_app_version", "is", null);
-				if (where?.id?.eq) query = query.eq("id", where.id.eq);
-				if (where?.id?.gt) query = query.gt("id", where.id.gt);
-				if (where?.id?.gte) query = query.gte("id", where.id.gte);
-				if (where?.id?.lt) query = query.lt("id", where.id.lt);
-				if (where?.id?.lte) query = query.lte("id", where.id.lte);
-				if (where?.id?.in) query = query.in("id", where.id.in);
-				if (limit) query = query.limit(limit);
-				if (offset) query = query.range(offset, offset + (limit || 20) - 1);
-				const { data } = await query;
-				const patchMap = await fetchPatchMap((data ?? []).map((bundle) => bundle.id));
-				return {
-					data: (data ?? []).map((bundle) => mapRowToBundle(bundle, patchMap.get(bundle.id) ?? [])),
-					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: patchDeleteError } = await supabase.from("bundle_patches").delete().eq("bundle_id", op.data.id);
-					if (patchDeleteError) throw new Error(`Failed to delete bundle patches: ${patchDeleteError.message}`);
-					const { error: basePatchDeleteError } = await supabase.from("bundle_patches").delete().eq("base_bundle_id", op.data.id);
-					if (basePatchDeleteError) throw new Error(`Failed to delete base bundle patches: ${basePatchDeleteError.message}`);
-					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 patchRows = bundleToPatchRows(bundle);
-					const { error } = await supabase.from("bundles").upsert(bundleToRow(bundle), { onConflict: "id" });
-					if (error) throw error;
-					const { error: patchDeleteError } = await supabase.from("bundle_patches").delete().eq("bundle_id", bundle.id);
-					if (patchDeleteError) throw patchDeleteError;
-					if (patchRows.length > 0) {
-						const { error: patchInsertError } = await supabase.from("bundle_patches").upsert(patchRows, { onConflict: "id" });
-						if (patchInsertError) throw patchInsertError;
-					}
-				}
-			}
-		};
-	}
-});
-//#endregion
-//#region src/supabaseEdgeFunctionDatabase.ts
-const supabaseEdgeFunctionDatabase = (config, hooks) => {
-	return supabaseDatabase({
-		supabaseUrl: config.supabaseUrl,
-		supabaseServiceRoleKey: config.supabaseServiceRoleKey
-	}, hooks);
-};
-//#endregion
-//#region src/supabaseSignedUrlBatcher.ts
-function getErrorMessage(error) {
-	if (error instanceof Error) return error.message;
-	if (error && typeof error === "object" && "message" in error && typeof error.message === "string") return error.message;
-	return String(error);
-}
-const createSupabaseSignedUrlBatcher = ({ createSignedUrls, expiresIn, formatObjectPath }) => {
-	let pendingByBucket = /* @__PURE__ */ new Map();
-	let flushScheduled = false;
-	const createSignedUrlError = (bucketName, key, error) => /* @__PURE__ */ new Error(`Failed to generate download URL for "${formatObjectPath(bucketName, key)}": ${getErrorMessage(error)}`);
-	const flush = async () => {
-		const batches = pendingByBucket;
-		pendingByBucket = /* @__PURE__ */ new Map();
-		flushScheduled = false;
-		await Promise.all([...batches.entries()].map(async ([bucketName, pending]) => {
-			try {
-				const { data, error } = await createSignedUrls(bucketName, pending.map(({ key }) => key), expiresIn);
-				if (error || !data) {
-					const batchError = error ?? /* @__PURE__ */ new Error("missing signed URL response");
-					for (const request of pending) request.reject(createSignedUrlError(bucketName, request.key, batchError));
-					return;
-				}
-				pending.forEach((request, index) => {
-					const result = data[index];
-					if (!result?.error && result?.signedUrl) {
-						request.resolve(result.signedUrl);
-						return;
-					}
-					request.reject(createSignedUrlError(bucketName, request.key, result?.error ?? /* @__PURE__ */ new Error("missing signed URL")));
-				});
-			} catch (error) {
-				for (const request of pending) request.reject(createSignedUrlError(bucketName, request.key, error));
-			}
-		}));
-	};
-	return (bucketName, key) => new Promise((resolve, reject) => {
-		const pending = pendingByBucket.get(bucketName) ?? [];
-		pending.push({
-			key,
-			reject,
-			resolve
-		});
-		pendingByBucket.set(bucketName, pending);
-		if (!flushScheduled) {
-			flushScheduled = true;
-			queueMicrotask(() => {
-				flush();
-			});
-		}
-	});
-};
-//#endregion
-//#region src/supabaseEdgeFunctionStorage.ts
-const parseSupabaseStorageUri = (storageUri) => {
-	const { bucket: bucketName, key } = parseStorageUri(storageUri, "supabase-storage");
-	if (!bucketName || !key) throw new Error("Invalid Supabase storage URI");
-	return {
-		bucketName,
-		key
-	};
-};
-const supabaseEdgeFunctionStorage = createRuntimeStoragePlugin({
-	name: "supabaseEdgeFunctionStorage",
-	supportedProtocol: "supabase-storage",
-	factory: (config) => {
-		const supabase = createClient(config.supabaseUrl, config.supabaseServiceRoleKey);
-		const resolveSignedUrl = createSupabaseSignedUrlBatcher({
-			createSignedUrls: (bucketName, keys, expiresIn) => supabase.storage.from(bucketName).createSignedUrls(keys, expiresIn),
-			expiresIn: config.signedUrlExpiresIn ?? 3600,
-			formatObjectPath: (bucketName, key) => `${bucketName}/${key}`
-		});
-		return {
-			async readText(storageUri) {
-				const { bucketName, key } = parseSupabaseStorageUri(storageUri);
-				const { data, error } = await supabase.storage.from(bucketName).download(key);
-				if (error) {
-					if (error.message?.includes("not found")) return null;
-					throw new Error(`Failed to read storage text: ${error.message}`);
-				}
-				if (!data) return null;
-				return data.text();
-			},
-			async getDownloadUrl(storageUri) {
-				const { bucketName, key } = parseSupabaseStorageUri(storageUri);
-				return { fileUrl: await resolveSignedUrl(bucketName, key) };
-			}
-		};
-	}
-});
-//#endregion
-export { resolveSupabaseServiceRoleKey as a, supabaseDatabase as i, createSupabaseSignedUrlBatcher as n, supabaseEdgeFunctionDatabase as r, supabaseEdgeFunctionStorage as t };

package/supabase/migrations/20250103114225_init.sql

@@ -1,228 +0,0 @@
--- HotUpdater.bundles
-
-CREATE TYPE platforms AS ENUM ('ios', 'android');
-
-CREATE TABLE bundles (
-    id uuid PRIMARY KEY,
-    platform platforms NOT NULL,
-    target_app_version text NOT NULL,
-    should_force_update boolean NOT NULL,
-    enabled boolean NOT NULL,
-    file_url text NOT NULL,
-    file_hash text NOT NULL,
-    git_commit_hash text,
-    message text
-);
-
-CREATE INDEX bundles_target_app_version_idx ON bundles(target_app_version);
-
-
--- HotUpdater.get_update_info
-
-CREATE OR REPLACE FUNCTION get_update_info (
-    app_platform   platforms,
-    app_version text,
-    bundle_id  uuid
-)
-RETURNS TABLE (
-    id            uuid,
-    should_force_update  boolean,
-    file_url      text,
-    file_hash     text,
-    status        text
-)
-LANGUAGE plpgsql
-AS
-$$
-DECLARE
-    NIL_UUID CONSTANT uuid := '00000000-0000-0000-0000-000000000000';
-BEGIN
-    RETURN QUERY
-    WITH rollback_candidate AS (
-        SELECT
-            b.id,
-            -- If status is 'ROLLBACK', should_force_update is always TRUE
-            TRUE AS should_force_update,
-            b.file_url,
-            b.file_hash,
-            'ROLLBACK' AS status
-        FROM bundles b
-        WHERE b.enabled = TRUE
-          AND b.platform = app_platform
-          AND b.id < bundle_id
-        ORDER BY b.id DESC
-        LIMIT 1
-    ),
-    update_candidate AS (
-        SELECT
-            b.id,
-            b.should_force_update,
-            b.file_url,
-            b.file_hash,
-            'UPDATE' AS status
-        FROM bundles b
-        WHERE b.enabled = TRUE
-          AND b.platform = app_platform
-          AND b.id >= bundle_id
-          AND semver_satisfies(b.target_app_version, app_version)
-        ORDER BY b.id DESC
-        LIMIT 1
-    ),
-    final_result AS (
-        SELECT *
-        FROM update_candidate
-
-        UNION ALL
-
-        SELECT *
-        FROM rollback_candidate
-        WHERE NOT EXISTS (SELECT 1 FROM update_candidate)
-    )
-    SELECT *
-    FROM final_result WHERE final_result.id != bundle_id
-
-    UNION ALL
-    /*
-      When there are no final results and bundle_id != NIL_UUID,
-      add one fallback row.
-      This fallback row is also ROLLBACK so shouldForceUpdate = TRUE.
-    */
-    SELECT
-        NIL_UUID      AS id,
-        TRUE          AS should_force_update,  -- Always TRUE
-        NULL          AS file_url,
-        NULL          AS file_hash,
-        'ROLLBACK'    AS status
-    WHERE (SELECT COUNT(*) FROM final_result) = 0
-      AND bundle_id != NIL_UUID;
-
-END;
-$$;
-
--- HotUpdater.semver_satisfies
-
-CREATE OR REPLACE FUNCTION semver_satisfies(range_expression TEXT, version TEXT)
-RETURNS BOOLEAN AS $$
-DECLARE
-    version_parts TEXT[];
-    version_major INT;
-    version_minor INT;
-    version_patch INT;
-    satisfies BOOLEAN := FALSE;
-BEGIN
-    -- Split the version into major, minor, and patch
-    version_parts := string_to_array(version, '.');
-    version_major := version_parts[1]::INT;
-    version_minor := version_parts[2]::INT;
-    version_patch := version_parts[3]::INT;
-
-    -- Parse range expression and evaluate
-    IF range_expression ~ '^\d+\.\d+\.\d+$' THEN
-        -- Exact match
-        satisfies := (range_expression = version);
-
-    ELSIF range_expression = '*' THEN
-        -- Matches any version
-        satisfies := TRUE;
-
-    ELSIF range_expression ~ '^\d+\.x\.x$' THEN
-        -- Matches major.x.x
-        DECLARE
-            major_range INT := split_part(range_expression, '.', 1)::INT;
-        BEGIN
-            satisfies := (version_major = major_range);
-        END;
-
-    ELSIF range_expression ~ '^\d+\.\d+\.x$' THEN
-        -- Matches major.minor.x
-        DECLARE
-            major_range INT := split_part(range_expression, '.', 1)::INT;
-            minor_range INT := split_part(range_expression, '.', 2)::INT;
-        BEGIN
-            satisfies := (version_major = major_range AND version_minor = minor_range);
-        END;
-
-    ELSIF range_expression ~ '^\d+\.\d+$' THEN
-        -- Matches major.minor
-        DECLARE
-            major_range INT := split_part(range_expression, '.', 1)::INT;
-            minor_range INT := split_part(range_expression, '.', 2)::INT;
-        BEGIN
-            satisfies := (version_major = major_range AND version_minor = minor_range);
-        END;
-
-    ELSIF range_expression ~ '^\d+\.\d+\.\d+ - \d+\.\d+\.\d+$' THEN
-        -- Matches range e.g., 1.2.3 - 1.2.7
-        DECLARE
-            lower_bound TEXT := split_part(range_expression, ' - ', 1);
-            upper_bound TEXT := split_part(range_expression, ' - ', 2);
-        BEGIN
-            satisfies := (version >= lower_bound AND version <= upper_bound);
-        END;
-
-    ELSIF range_expression ~ '^>=\d+\.\d+\.\d+ <\d+\.\d+\.\d+$' THEN
-        -- Matches range with inequalities
-        DECLARE
-            lower_bound TEXT := regexp_replace(range_expression, '>=([\d\.]+) <.*', '\1');
-            upper_bound TEXT := regexp_replace(range_expression, '.*<([\d\.]+)', '\1');
-        BEGIN
-            satisfies := (version >= lower_bound AND version < upper_bound);
-        END;
-
-    ELSIF range_expression ~ '^~\d+\.\d+\.\d+$' THEN
-        -- Matches ~1.2.3 (>=1.2.3 <1.3.0)
-        DECLARE
-            lower_bound TEXT := regexp_replace(range_expression, '~', '');
-            upper_bound_major INT := split_part(lower_bound, '.', 1)::INT;
-            upper_bound_minor INT := split_part(lower_bound, '.', 2)::INT + 1;
-            upper_bound TEXT := upper_bound_major || '.' || upper_bound_minor || '.0';
-        BEGIN
-            satisfies := (version >= lower_bound AND version < upper_bound);
-        END;
-
-    ELSIF range_expression ~ '^\^\d+\.\d+\.\d+$' THEN
-        -- Matches ^1.2.3 (>=1.2.3 <2.0.0)
-        DECLARE
-            lower_bound TEXT := regexp_replace(range_expression, '\^', '');
-            upper_bound_major INT := split_part(lower_bound, '.', 1)::INT + 1;
-            upper_bound TEXT := upper_bound_major || '.0.0';
-        BEGIN
-            satisfies := (version >= lower_bound AND version < upper_bound);
-        END;
-
-    -- [Added] 1) Single major version pattern '^(\d+)$'
-    ELSIF range_expression ~ '^\d+$' THEN
-        /*
-            e.g.) "1" is interpreted as (>=1.0.0 <2.0.0) in semver range
-                  "2" would be interpreted as (>=2.0.0 <3.0.0)
-         */
-        DECLARE
-            major_range INT := range_expression::INT;
-            lower_bound TEXT := major_range || '.0.0';
-            upper_bound TEXT := (major_range + 1) || '.0.0';
-        BEGIN
-            satisfies := (version >= lower_bound AND version < upper_bound);
-        END;
-
-    -- [Added] 2) major.x pattern '^(\d+)\.x$'
-    ELSIF range_expression ~ '^\d+\.x$' THEN
-        /*
-            e.g.) "2.x" => as long as major=2 matches, any minor and patch is OK
-                  effectively works like (>=2.0.0 <3.0.0)
-         */
-        DECLARE
-            major_range INT := split_part(range_expression, '.', 1)::INT;
-            lower_bound TEXT := major_range || '.0.0';
-            upper_bound TEXT := (major_range + 1) || '.0.0';
-        BEGIN
-            satisfies := (version >= lower_bound AND version < upper_bound);
-        END;
-
-    ELSE
-        RAISE EXCEPTION 'Unsupported range expression: %', range_expression;
-    END IF;
-
-    RETURN satisfies;
-END;
-$$ LANGUAGE plpgsql;
-