@hot-updater/supabase 0.29.4 → 0.29.6

package/dist/supabaseEdgeFunctionStorage-DnnViEfo.mjs

@@ -0,0 +1,527 @@
+import { DEFAULT_ROLLOUT_COHORT_COUNT, NIL_UUID } from "@hot-updater/core";
+import { calculatePagination, createDatabasePlugin, filterCompatibleAppVersions } from "@hot-updater/plugin-core";
+import { createClient } from "@supabase/supabase-js";
+//#region ../../node_modules/.pnpm/map-obj@5.0.0/node_modules/map-obj/index.js
+const isObject$1 = (value) => typeof value === "object" && value !== null;
+const isObjectCustom = (value) => isObject$1(value) && !(value instanceof RegExp) && !(value instanceof Error) && !(value instanceof Date);
+const mapObjectSkip = Symbol("mapObjectSkip");
+const _mapObject = (object, mapper, options, isSeen = /* @__PURE__ */ new WeakMap()) => {
+	options = {
+		deep: false,
+		target: {},
+		...options
+	};
+	if (isSeen.has(object)) return isSeen.get(object);
+	isSeen.set(object, options.target);
+	const { target } = options;
+	delete options.target;
+	const mapArray = (array) => array.map((element) => isObjectCustom(element) ? _mapObject(element, mapper, options, isSeen) : element);
+	if (Array.isArray(object)) return mapArray(object);
+	for (const [key, value] of Object.entries(object)) {
+		const mapResult = mapper(key, value, object);
+		if (mapResult === mapObjectSkip) continue;
+		let [newKey, newValue, { shouldRecurse = true } = {}] = mapResult;
+		if (newKey === "__proto__") continue;
+		if (options.deep && shouldRecurse && isObjectCustom(newValue)) newValue = Array.isArray(newValue) ? mapArray(newValue) : _mapObject(newValue, mapper, options, isSeen);
+		target[newKey] = newValue;
+	}
+	return target;
+};
+function mapObject(object, mapper, options) {
+	if (!isObject$1(object)) throw new TypeError(`Expected an object, got \`${object}\` (${typeof object})`);
+	return _mapObject(object, mapper, options);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/camelcase@8.0.0/node_modules/camelcase/index.js
+const UPPERCASE = /[\p{Lu}]/u;
+const LOWERCASE = /[\p{Ll}]/u;
+const LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/gu;
+const IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
+const SEPARATORS = /[_.\- ]+/;
+const LEADING_SEPARATORS = new RegExp("^" + SEPARATORS.source);
+const SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, "gu");
+const NUMBERS_AND_IDENTIFIER = new RegExp("\\d+" + IDENTIFIER.source, "gu");
+const preserveCamelCase = (string, toLowerCase, toUpperCase, preserveConsecutiveUppercase) => {
+	let isLastCharLower = false;
+	let isLastCharUpper = false;
+	let isLastLastCharUpper = false;
+	let isLastLastCharPreserved = false;
+	for (let index = 0; index < string.length; index++) {
+		const character = string[index];
+		isLastLastCharPreserved = index > 2 ? string[index - 3] === "-" : true;
+		if (isLastCharLower && UPPERCASE.test(character)) {
+			string = string.slice(0, index) + "-" + string.slice(index);
+			isLastCharLower = false;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = true;
+			index++;
+		} else if (isLastCharUpper && isLastLastCharUpper && LOWERCASE.test(character) && (!isLastLastCharPreserved || preserveConsecutiveUppercase)) {
+			string = string.slice(0, index - 1) + "-" + string.slice(index - 1);
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = false;
+			isLastCharLower = true;
+		} else {
+			isLastCharLower = toLowerCase(character) === character && toUpperCase(character) !== character;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = toUpperCase(character) === character && toLowerCase(character) !== character;
+		}
+	}
+	return string;
+};
+const preserveConsecutiveUppercase = (input, toLowerCase) => {
+	LEADING_CAPITAL.lastIndex = 0;
+	return input.replaceAll(LEADING_CAPITAL, (match) => toLowerCase(match));
+};
+const postProcess = (input, toUpperCase) => {
+	SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
+	NUMBERS_AND_IDENTIFIER.lastIndex = 0;
+	return input.replaceAll(NUMBERS_AND_IDENTIFIER, (match, pattern, offset) => ["_", "-"].includes(input.charAt(offset + match.length)) ? match : toUpperCase(match)).replaceAll(SEPARATORS_AND_IDENTIFIER, (_, identifier) => toUpperCase(identifier));
+};
+function camelCase(input, options) {
+	if (!(typeof input === "string" || Array.isArray(input))) throw new TypeError("Expected the input to be `string | string[]`");
+	options = {
+		pascalCase: false,
+		preserveConsecutiveUppercase: false,
+		...options
+	};
+	if (Array.isArray(input)) input = input.map((x) => x.trim()).filter((x) => x.length).join("-");
+	else input = input.trim();
+	if (input.length === 0) return "";
+	const toLowerCase = options.locale === false ? (string) => string.toLowerCase() : (string) => string.toLocaleLowerCase(options.locale);
+	const toUpperCase = options.locale === false ? (string) => string.toUpperCase() : (string) => string.toLocaleUpperCase(options.locale);
+	if (input.length === 1) {
+		if (SEPARATORS.test(input)) return "";
+		return options.pascalCase ? toUpperCase(input) : toLowerCase(input);
+	}
+	if (input !== toLowerCase(input)) input = preserveCamelCase(input, toLowerCase, toUpperCase, options.preserveConsecutiveUppercase);
+	input = input.replace(LEADING_SEPARATORS, "");
+	input = options.preserveConsecutiveUppercase ? preserveConsecutiveUppercase(input, toLowerCase) : toLowerCase(input);
+	if (options.pascalCase) input = toUpperCase(input.charAt(0)) + input.slice(1);
+	return postProcess(input, toUpperCase);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/quick-lru@6.1.2/node_modules/quick-lru/index.js
+var QuickLRU = class extends Map {
+	constructor(options = {}) {
+		super();
+		if (!(options.maxSize && options.maxSize > 0)) throw new TypeError("`maxSize` must be a number greater than 0");
+		if (typeof options.maxAge === "number" && options.maxAge === 0) throw new TypeError("`maxAge` must be a number greater than 0");
+		this.maxSize = options.maxSize;
+		this.maxAge = options.maxAge || Number.POSITIVE_INFINITY;
+		this.onEviction = options.onEviction;
+		this.cache = /* @__PURE__ */ new Map();
+		this.oldCache = /* @__PURE__ */ new Map();
+		this._size = 0;
+	}
+	_emitEvictions(cache) {
+		if (typeof this.onEviction !== "function") return;
+		for (const [key, item] of cache) this.onEviction(key, item.value);
+	}
+	_deleteIfExpired(key, item) {
+		if (typeof item.expiry === "number" && item.expiry <= Date.now()) {
+			if (typeof this.onEviction === "function") this.onEviction(key, item.value);
+			return this.delete(key);
+		}
+		return false;
+	}
+	_getOrDeleteIfExpired(key, item) {
+		if (this._deleteIfExpired(key, item) === false) return item.value;
+	}
+	_getItemValue(key, item) {
+		return item.expiry ? this._getOrDeleteIfExpired(key, item) : item.value;
+	}
+	_peek(key, cache) {
+		const item = cache.get(key);
+		return this._getItemValue(key, item);
+	}
+	_set(key, value) {
+		this.cache.set(key, value);
+		this._size++;
+		if (this._size >= this.maxSize) {
+			this._size = 0;
+			this._emitEvictions(this.oldCache);
+			this.oldCache = this.cache;
+			this.cache = /* @__PURE__ */ new Map();
+		}
+	}
+	_moveToRecent(key, item) {
+		this.oldCache.delete(key);
+		this._set(key, item);
+	}
+	*_entriesAscending() {
+		for (const item of this.oldCache) {
+			const [key, value] = item;
+			if (!this.cache.has(key)) {
+				if (this._deleteIfExpired(key, value) === false) yield item;
+			}
+		}
+		for (const item of this.cache) {
+			const [key, value] = item;
+			if (this._deleteIfExpired(key, value) === false) yield item;
+		}
+	}
+	get(key) {
+		if (this.cache.has(key)) {
+			const item = this.cache.get(key);
+			return this._getItemValue(key, item);
+		}
+		if (this.oldCache.has(key)) {
+			const item = this.oldCache.get(key);
+			if (this._deleteIfExpired(key, item) === false) {
+				this._moveToRecent(key, item);
+				return item.value;
+			}
+		}
+	}
+	set(key, value, { maxAge = this.maxAge } = {}) {
+		const expiry = typeof maxAge === "number" && maxAge !== Number.POSITIVE_INFINITY ? Date.now() + maxAge : void 0;
+		if (this.cache.has(key)) this.cache.set(key, {
+			value,
+			expiry
+		});
+		else this._set(key, {
+			value,
+			expiry
+		});
+		return this;
+	}
+	has(key) {
+		if (this.cache.has(key)) return !this._deleteIfExpired(key, this.cache.get(key));
+		if (this.oldCache.has(key)) return !this._deleteIfExpired(key, this.oldCache.get(key));
+		return false;
+	}
+	peek(key) {
+		if (this.cache.has(key)) return this._peek(key, this.cache);
+		if (this.oldCache.has(key)) return this._peek(key, this.oldCache);
+	}
+	delete(key) {
+		const deleted = this.cache.delete(key);
+		if (deleted) this._size--;
+		return this.oldCache.delete(key) || deleted;
+	}
+	clear() {
+		this.cache.clear();
+		this.oldCache.clear();
+		this._size = 0;
+	}
+	resize(newSize) {
+		if (!(newSize && newSize > 0)) throw new TypeError("`maxSize` must be a number greater than 0");
+		const items = [...this._entriesAscending()];
+		const removeCount = items.length - newSize;
+		if (removeCount < 0) {
+			this.cache = new Map(items);
+			this.oldCache = /* @__PURE__ */ new Map();
+			this._size = items.length;
+		} else {
+			if (removeCount > 0) this._emitEvictions(items.slice(0, removeCount));
+			this.oldCache = new Map(items.slice(removeCount));
+			this.cache = /* @__PURE__ */ new Map();
+			this._size = 0;
+		}
+		this.maxSize = newSize;
+	}
+	*keys() {
+		for (const [key] of this) yield key;
+	}
+	*values() {
+		for (const [, value] of this) yield value;
+	}
+	*[Symbol.iterator]() {
+		for (const item of this.cache) {
+			const [key, value] = item;
+			if (this._deleteIfExpired(key, value) === false) yield [key, value.value];
+		}
+		for (const item of this.oldCache) {
+			const [key, value] = item;
+			if (!this.cache.has(key)) {
+				if (this._deleteIfExpired(key, value) === false) yield [key, value.value];
+			}
+		}
+	}
+	*entriesDescending() {
+		let items = [...this.cache];
+		for (let i = items.length - 1; i >= 0; --i) {
+			const [key, value] = items[i];
+			if (this._deleteIfExpired(key, value) === false) yield [key, value.value];
+		}
+		items = [...this.oldCache];
+		for (let i = items.length - 1; i >= 0; --i) {
+			const [key, value] = items[i];
+			if (!this.cache.has(key)) {
+				if (this._deleteIfExpired(key, value) === false) yield [key, value.value];
+			}
+		}
+	}
+	*entriesAscending() {
+		for (const [key, value] of this._entriesAscending()) yield [key, value.value];
+	}
+	get size() {
+		if (!this._size) return this.oldCache.size;
+		let oldCacheSize = 0;
+		for (const key of this.oldCache.keys()) if (!this.cache.has(key)) oldCacheSize++;
+		return Math.min(this._size + oldCacheSize, this.maxSize);
+	}
+	entries() {
+		return this.entriesAscending();
+	}
+	forEach(callbackFunction, thisArgument = this) {
+		for (const [key, value] of this.entriesAscending()) callbackFunction.call(thisArgument, value, key, this);
+	}
+	get [Symbol.toStringTag]() {
+		return JSON.stringify([...this.entriesAscending()]);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/camelcase-keys@9.1.3/node_modules/camelcase-keys/index.js
+const has = (array, key) => array.some((element) => {
+	if (typeof element === "string") return element === key;
+	element.lastIndex = 0;
+	return element.test(key);
+});
+const cache = new QuickLRU({ maxSize: 1e5 });
+const isObject = (value) => typeof value === "object" && value !== null && !(value instanceof RegExp) && !(value instanceof Error) && !(value instanceof Date);
+const transform = (input, options = {}) => {
+	if (!isObject(input)) return input;
+	const { exclude, pascalCase = false, stopPaths, deep = false, preserveConsecutiveUppercase = false } = options;
+	const stopPathsSet = new Set(stopPaths);
+	const makeMapper = (parentPath) => (key, value) => {
+		if (deep && isObject(value)) {
+			const path = parentPath === void 0 ? key : `${parentPath}.${key}`;
+			if (!stopPathsSet.has(path)) value = mapObject(value, makeMapper(path));
+		}
+		if (!(exclude && has(exclude, key))) {
+			const cacheKey = pascalCase ? `${key}_` : key;
+			if (cache.has(cacheKey)) key = cache.get(cacheKey);
+			else {
+				const returnValue = camelCase(key, {
+					pascalCase,
+					locale: false,
+					preserveConsecutiveUppercase
+				});
+				if (key.length < 100) cache.set(cacheKey, returnValue);
+				key = returnValue;
+			}
+		}
+		return [key, value];
+	};
+	return mapObject(input, makeMapper(void 0));
+};
+function camelcaseKeys(input, options) {
+	if (Array.isArray(input)) return Object.keys(input).map((key) => transform(input[key], options));
+	return transform(input, options);
+}
+//#endregion
+//#region src/getUpdateInfo.ts
+const appVersionStrategy = async (supabase, { platform, appVersion, bundleId, minBundleId = NIL_UUID, channel = "production", cohort }) => {
+	const { data: appVersionList, error: appVersionListError } = await supabase.rpc("get_target_app_version_list", {
+		app_platform: platform,
+		min_bundle_id: minBundleId
+	});
+	if (appVersionListError) throw appVersionListError;
+	const targetAppVersionList = filterCompatibleAppVersions((appVersionList ?? []).map((group) => group.target_app_version), appVersion);
+	const { data, error } = await supabase.rpc("get_update_info_by_app_version", {
+		app_platform: platform,
+		app_version: appVersion,
+		bundle_id: bundleId,
+		min_bundle_id: minBundleId,
+		target_channel: channel,
+		target_app_version_list: targetAppVersionList,
+		cohort: cohort ?? null
+	});
+	if (error) throw error;
+	const row = data?.[0];
+	return row ? camelcaseKeys(row) : null;
+};
+const fingerprintStrategy = async (supabase, { platform, fingerprintHash, bundleId, minBundleId = NIL_UUID, channel = "production", cohort }) => {
+	const { data, error } = await supabase.rpc("get_update_info_by_fingerprint_hash", {
+		app_platform: platform,
+		bundle_id: bundleId,
+		min_bundle_id: minBundleId,
+		target_channel: channel,
+		target_fingerprint_hash: fingerprintHash,
+		cohort: cohort ?? null
+	});
+	if (error) throw error;
+	const row = data?.[0];
+	return row ? camelcaseKeys(row) : null;
+};
+const getUpdateInfo = (supabase, args) => {
+	if (args._updateStrategy === "appVersion") return appVersionStrategy(supabase, args);
+	return fingerprintStrategy(supabase, args);
+};
+//#endregion
+//#region src/supabaseDatabase.ts
+const supabaseDatabase = createDatabasePlugin({
+	name: "supabaseDatabase",
+	factory: (config) => {
+		const supabase = createClient(config.supabaseUrl, config.supabaseAnonKey);
+		return {
+			async getUpdateInfo(args) {
+				return getUpdateInfo(supabase, args);
+			},
+			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, rollout_cohort_count, target_cohorts").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 ?? {},
+					rolloutCohortCount: data.rollout_cohort_count ?? DEFAULT_ROLLOUT_COHORT_COUNT,
+					targetCohorts: data.target_cohorts ?? null
+				};
+			},
+			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("id, channel, enabled, platform, should_force_update, file_hash, git_commit_hash, message, fingerprint_hash, target_app_version, storage_uri, metadata, rollout_cohort_count, target_cohorts").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;
+				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 ?? {},
+						rolloutCohortCount: bundle.rollout_cohort_count ?? DEFAULT_ROLLOUT_COHORT_COUNT,
+						targetCohorts: bundle.target_cohorts ?? null
+					})) : [],
+					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,
+						rollout_cohort_count: bundle.rolloutCohortCount ?? DEFAULT_ROLLOUT_COHORT_COUNT,
+						target_cohorts: bundle.targetCohorts ?? null
+					}, { onConflict: "id" });
+					if (error) throw error;
+				}
+			}
+		};
+	}
+});
+//#endregion
+//#region src/supabaseEdgeFunctionDatabase.ts
+const supabaseEdgeFunctionDatabase = (config, hooks) => {
+	return supabaseDatabase({
+		supabaseUrl: config.supabaseUrl,
+		supabaseAnonKey: config.supabaseServiceRoleKey
+	}, hooks);
+};
+//#endregion
+//#region src/supabaseEdgeFunctionStorage.ts
+const supabaseEdgeFunctionStorage = (config) => {
+	const supabase = createClient(config.supabaseUrl, config.supabaseServiceRoleKey);
+	return () => {
+		return {
+			name: "supabaseEdgeFunctionStorage",
+			supportedProtocol: "supabase-storage",
+			async upload() {
+				throw new Error("supabaseEdgeFunctionStorage does not support upload() in the edge runtime.");
+			},
+			async delete(storageUri) {
+				const storageUrl = new URL(storageUri);
+				if (storageUrl.protocol !== "supabase-storage:") throw new Error("Invalid Supabase storage URI protocol");
+				const bucketName = storageUrl.host;
+				const key = storageUrl.pathname.replace(/^\/+/, "");
+				if (!bucketName || !key) throw new Error("Invalid Supabase storage URI");
+				const { error } = await supabase.storage.from(bucketName).remove([key]);
+				if (error) throw new Error(`Failed to delete bundle: ${error.message}`);
+			},
+			async getDownloadUrl(storageUri) {
+				const storageUrl = new URL(storageUri);
+				if (storageUrl.protocol !== "supabase-storage:") throw new Error("Invalid Supabase storage URI protocol");
+				const bucketName = storageUrl.host;
+				const key = storageUrl.pathname.replace(/^\/+/, "");
+				if (!bucketName || !key) throw new Error("Invalid Supabase storage URI");
+				const { data, error } = await supabase.storage.from(bucketName).createSignedUrl(key, config.signedUrlExpiresIn ?? 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 { supabaseEdgeFunctionDatabase as n, supabaseDatabase as r, supabaseEdgeFunctionStorage as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hot-updater/supabase",
   "type": "module",
-  "version": "0.29.4",
+  "version": "0.29.6",
   "description": "React Native OTA solution for self-hosted",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -47,10 +47,10 @@
     "@supabase/supabase-js": "^2.76.1",
     "hono": "4.12.9",
     "uuidv7": "^1.0.2",
-    "@hot-updater/core": "0.29.4",
-    "@hot-updater/cli-tools": "0.29.4",
-    "@hot-updater/plugin-core": "0.29.4",
-    "@hot-updater/server": "0.29.4"
+    "@hot-updater/core": "0.29.6",
+    "@hot-updater/cli-tools": "0.29.6",
+    "@hot-updater/plugin-core": "0.29.6",
+    "@hot-updater/server": "0.29.6"
   },
   "devDependencies": {
     "@electric-sql/pglite": "^0.2.15",
@@ -60,10 +60,10 @@
     "execa": "9.5.2",
     "@types/node": "^20",
     "mime": "^4.0.4",
-    "@hot-updater/js": "0.29.4",
-    "@hot-updater/mock": "0.29.4",
-    "@hot-updater/test-utils": "0.29.4",
-    "@hot-updater/postgres": "0.29.4"
+    "@hot-updater/mock": "0.29.6",
+    "@hot-updater/postgres": "0.29.6",
+    "@hot-updater/test-utils": "0.29.6",
+    "@hot-updater/js": "0.29.6"
   },
   "scripts": {
     "build": "tsdown",