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

package/dist/supabaseStorage-yP7u4m7E.cjs

@@ -0,0 +1,568 @@
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
+let _supabase_supabase_js = require("@supabase/supabase-js");
+//#region src/supabaseConfig.ts
+const resolveSupabaseServiceRoleKey = (config) => {
+	if (!config.supabaseServiceRoleKey) throw new Error("Supabase service role key is required. Set supabaseServiceRoleKey.");
+	return config.supabaseServiceRoleKey;
+};
+//#endregion
+//#region src/supabaseFilter.ts
+var InvalidSupabasePredicateError = class extends Error {
+	name = "InvalidSupabasePredicateError";
+};
+const encodeValue = (value) => {
+	if (typeof value !== "string") return String(value);
+	return `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+};
+const encodePattern = (value) => encodeValue(value.replaceAll("*", "\\*").replaceAll("%", "\\%").replaceAll("_", "\\_"));
+const predicate = (condition) => {
+	const operator = condition.operator ?? "eq";
+	const field = condition.field;
+	switch (operator) {
+		case "eq":
+		case "ne":
+			if (condition.value === null) return `${field}.${operator === "eq" ? "is" : "not.is"}.null`;
+			if (typeof condition.value !== "boolean" && typeof condition.value !== "number" && typeof condition.value !== "string") throw new InvalidSupabasePredicateError();
+			if ("mode" in condition && condition.mode === "insensitive") {
+				const comparison = encodePattern(condition.value);
+				return `${field}.${operator === "eq" ? "ilike" : "not.ilike"}.${comparison}`;
+			}
+			return `${field}.${operator === "eq" ? "eq" : "neq"}.${encodeValue(condition.value)}`;
+		case "gt":
+		case "gte":
+		case "lt":
+		case "lte":
+			if (typeof condition.value !== "number" && typeof condition.value !== "string") throw new InvalidSupabasePredicateError();
+			return `${field}.${operator}.${encodeValue(condition.value)}`;
+		case "in":
+		case "not_in": {
+			if (!Array.isArray(condition.value)) throw new InvalidSupabasePredicateError();
+			if (condition.value.length === 0) return operator === "in" ? `and(${field}.is.null,${field}.not.is.null)` : `or(${field}.is.null,${field}.not.is.null)`;
+			const values = condition.value.map(encodeValue).join(",");
+			return `${field}.${operator === "in" ? "in" : "not.in"}.(${values})`;
+		}
+		case "contains":
+		case "starts_with":
+		case "ends_with": {
+			if (typeof condition.value !== "string") throw new InvalidSupabasePredicateError();
+			const value = encodePattern(condition.value).slice(1, -1);
+			const pattern = operator === "contains" ? `"*${value}*"` : operator === "starts_with" ? `"${value}*"` : `"*${value}"`;
+			return `${field}.${"mode" in condition && condition.mode === "insensitive" ? "ilike" : "like"}.${pattern}`;
+		}
+	}
+};
+const buildSupabaseFilter = (where) => {
+	const [first, ...rest] = where ?? [];
+	if (first === void 0) return;
+	let expression = predicate(first);
+	for (const condition of rest) {
+		const next = predicate(condition);
+		expression = condition.connector === "OR" ? `or(${expression},${next})` : `and(${expression},${next})`;
+	}
+	return expression;
+};
+//#endregion
+//#region src/supabaseInfrastructureNames.ts
+const SUPABASE_V1_TABLE_NAMES = {
+	apiKeys: "hot_updater_v1_api_keys",
+	bundleEvents: "hot_updater_v1_bundle_events",
+	bundlePatches: "hot_updater_v1_bundle_patches",
+	bundles: "hot_updater_v1_bundles",
+	channels: "hot_updater_v1_channels",
+	releaseCatalogs: "hot_updater_v1_release_catalogs",
+	releases: "hot_updater_v1_releases",
+	settings: "hot_updater_v1_private_settings"
+};
+const SUPABASE_V1_FUNCTION_NAMES = {
+	commit: "hot_updater_v1_commit",
+	deleteChannel: "hot_updater_v1_delete_channel"
+};
+//#endregion
+//#region src/supabaseResult.ts
+var SupabaseDatabaseError = class extends Error {
+	name = "SupabaseDatabaseError";
+	constructor(operation, cause) {
+		super(`Supabase database operation failed: ${operation}`, { cause });
+		this.operation = operation;
+	}
+};
+var SupabaseMissingDataError = class extends Error {
+	name = "SupabaseMissingDataError";
+	constructor(operation) {
+		super(`Supabase database operation returned no row: ${operation}`);
+		this.operation = operation;
+	}
+};
+const throwSupabaseError = (operation, error) => {
+	if (error !== null) throw new SupabaseDatabaseError(operation, error);
+};
+//#endregion
+//#region src/supabaseDatabase.ts
+const isForeignKeyViolation = (error) => typeof error === "object" && error !== null && Reflect.get(error, "code") === "23503";
+const createSupabaseImplementation = (supabase) => {
+	const implementation = {
+		async create(input) {
+			switch (input.model) {
+				case "bundles": {
+					const { data, error } = await supabase.from(SUPABASE_V1_TABLE_NAMES.bundles).insert(input.data).select("*").single();
+					throwSupabaseError("create bundles", error);
+					if (data === null) throw new SupabaseMissingDataError("create bundles");
+					return data;
+				}
+				case "bundle_patches": {
+					const { data, error } = await supabase.from(SUPABASE_V1_TABLE_NAMES.bundlePatches).insert(input.data).select("*").single();
+					throwSupabaseError("create bundle_patches", error);
+					if (data === null) throw new SupabaseMissingDataError("create bundle_patches");
+					return data;
+				}
+				case "channels": {
+					if (input.onConflict === "ignore") {
+						const { data, error } = await supabase.from(SUPABASE_V1_TABLE_NAMES.channels).upsert(input.data, {
+							onConflict: "name",
+							ignoreDuplicates: true
+						}).select("*").maybeSingle();
+						throwSupabaseError("create channels", error);
+						return data ?? input.data;
+					}
+					const { data, error } = await supabase.from(SUPABASE_V1_TABLE_NAMES.channels).insert(input.data).select("*").single();
+					throwSupabaseError("create channels", error);
+					if (data === null) throw new SupabaseMissingDataError("create channels");
+					return data;
+				}
+				case "bundle_events": {
+					const { data, error } = await supabase.from(SUPABASE_V1_TABLE_NAMES.bundleEvents).insert(input.data).select("*").single();
+					throwSupabaseError("create bundle_events", error);
+					if (data === null) throw new SupabaseMissingDataError("create bundle_events");
+					return data;
+				}
+				case "releases": {
+					const { data, error } = await supabase.from(SUPABASE_V1_TABLE_NAMES.releases).insert(input.data).select("*").single();
+					throwSupabaseError("create releases", error);
+					if (data === null) throw new SupabaseMissingDataError("create releases");
+					return data;
+				}
+				case "release_catalogs": {
+					const { data, error } = await supabase.from(SUPABASE_V1_TABLE_NAMES.releaseCatalogs).insert(input.data).select("*").single();
+					throwSupabaseError("create release_catalogs", error);
+					if (data === null) throw new SupabaseMissingDataError("create release_catalogs");
+					return data;
+				}
+				case "api_keys": {
+					const { data, error } = await (input.onConflict === "ignore" ? supabase.from(SUPABASE_V1_TABLE_NAMES.apiKeys).upsert(input.data, {
+						onConflict: "hash",
+						ignoreDuplicates: true
+					}) : supabase.from(SUPABASE_V1_TABLE_NAMES.apiKeys).insert(input.data)).select("*").maybeSingle();
+					throwSupabaseError("create api_keys", error);
+					if (data === null && input.onConflict !== "ignore") throw new SupabaseMissingDataError("create api_keys");
+					return data ?? input.data;
+				}
+			}
+		},
+		async update(input) {
+			const filter = buildSupabaseFilter(input.where);
+			if (input.model === "api_keys") {
+				let query = supabase.from(SUPABASE_V1_TABLE_NAMES.apiKeys).update(input.update);
+				if (filter !== void 0) query = query.or(filter);
+				const { data, error } = await query.select("*").maybeSingle();
+				throwSupabaseError("update api_keys", error);
+				return data;
+			}
+			if (input.model === "releases") {
+				let query = supabase.from(SUPABASE_V1_TABLE_NAMES.releases).update(input.update);
+				if (filter !== void 0) query = query.or(filter);
+				const { data, error } = await query.select("*").maybeSingle();
+				throwSupabaseError("update releases", error);
+				return data;
+			}
+			if (input.model === "release_catalogs") {
+				let query = supabase.from(SUPABASE_V1_TABLE_NAMES.releaseCatalogs).update(input.update);
+				if (filter !== void 0) query = query.or(filter);
+				const { data, error } = await query.select("*").maybeSingle();
+				throwSupabaseError("update release_catalogs", error);
+				return data;
+			}
+			let query = supabase.from(SUPABASE_V1_TABLE_NAMES.bundles).update(input.update);
+			if (filter !== void 0) query = query.or(filter);
+			const { data, error } = await query.select("*").maybeSingle();
+			throwSupabaseError("update bundles", error);
+			return data;
+		},
+		async delete(input) {
+			const filter = buildSupabaseFilter(input.where);
+			switch (input.model) {
+				case "bundles": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.bundles).delete();
+					if (filter !== void 0) query = query.or(filter);
+					const { error } = await query;
+					throwSupabaseError("delete bundles", error);
+					return;
+				}
+				case "bundle_patches": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.bundlePatches).delete();
+					if (filter !== void 0) query = query.or(filter);
+					const { error } = await query;
+					throwSupabaseError("delete bundle_patches", error);
+					return;
+				}
+				case "channels": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.channels).delete();
+					if (filter !== void 0) query = query.or(filter);
+					const { error } = await query;
+					if (isForeignKeyViolation(error)) throw new _hot_updater_plugin_core_internal.DatabaseRowReferencedError();
+					throwSupabaseError("delete channels", error);
+				}
+				case "releases": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.releases).delete();
+					if (filter !== void 0) query = query.or(filter);
+					const { error } = await query;
+					throwSupabaseError("delete releases", error);
+				}
+			}
+		},
+		async count(input) {
+			if (input.distinct !== void 0) throw new _hot_updater_plugin_core.DatabasePluginInputError("invalid-operation");
+			const filter = buildSupabaseFilter(input.where);
+			switch (input.model) {
+				case "bundles": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.bundles).select("*", {
+						count: "exact",
+						head: true
+					});
+					if (filter !== void 0) query = query.or(filter);
+					const { count, error } = await query;
+					throwSupabaseError("count bundles", error);
+					return count ?? 0;
+				}
+				case "bundle_patches": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.bundlePatches).select("*", {
+						count: "exact",
+						head: true
+					});
+					if (filter !== void 0) query = query.or(filter);
+					const { count, error } = await query;
+					throwSupabaseError("count bundle_patches", error);
+					return count ?? 0;
+				}
+				case "releases": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.releases).select("*", {
+						count: "exact",
+						head: true
+					});
+					if (filter !== void 0) query = query.or(filter);
+					const { count, error } = await query;
+					throwSupabaseError("count releases", error);
+					return count ?? 0;
+				}
+			}
+		},
+		async findOne(input) {
+			const filter = buildSupabaseFilter(input.where);
+			switch (input.model) {
+				case "bundles": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.bundles).select("*");
+					if (filter !== void 0) query = query.or(filter);
+					const { data, error } = await query.limit(1).maybeSingle();
+					throwSupabaseError("findOne bundles", error);
+					return data;
+				}
+				case "api_keys": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.apiKeys).select("*");
+					if (filter !== void 0) query = query.or(filter);
+					const { data, error } = await query.limit(1).maybeSingle();
+					throwSupabaseError("findOne api_keys", error);
+					return data;
+				}
+				case "channels": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.channels).select("*");
+					if (filter !== void 0) query = query.or(filter);
+					const { data, error } = await query.limit(1).maybeSingle();
+					throwSupabaseError("findOne channels", error);
+					return data;
+				}
+				case "bundle_patches": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.bundlePatches).select("*");
+					if (filter !== void 0) query = query.or(filter);
+					const { data, error } = await query.limit(1).maybeSingle();
+					throwSupabaseError("findOne bundle_patches", error);
+					return data;
+				}
+				case "releases": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.releases).select("*");
+					if (filter !== void 0) query = query.or(filter);
+					const { data, error } = await query.limit(1).maybeSingle();
+					throwSupabaseError("findOne releases", error);
+					return data;
+				}
+				case "release_catalogs": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.releaseCatalogs).select("*");
+					if (filter !== void 0) query = query.or(filter);
+					const { data, error } = await query.limit(1).maybeSingle();
+					throwSupabaseError("findOne release_catalogs", error);
+					return data;
+				}
+			}
+		},
+		async findMany(input) {
+			if (input.distinctOn !== void 0) throw new _hot_updater_plugin_core.DatabasePluginInputError("invalid-operation");
+			if (input.limit === 0) return [];
+			const filter = buildSupabaseFilter(input.where);
+			const rangeEnd = input.offset + input.limit - 1;
+			const orderBy = input.orderBy ?? [];
+			switch (input.model) {
+				case "bundles": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.bundles).select("*");
+					if (filter !== void 0) query = query.or(filter);
+					for (const clause of orderBy) query = query.order(clause.field, {
+						ascending: clause.direction === "asc",
+						...clause.nulls ? { nullsFirst: clause.nulls === "first" } : {}
+					});
+					const { data, error } = await query.range(input.offset, rangeEnd);
+					throwSupabaseError("findMany bundles", error);
+					return data ?? [];
+				}
+				case "bundle_events": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.bundleEvents).select("*");
+					if (filter !== void 0) query = query.or(filter);
+					for (const clause of orderBy) query = query.order(clause.field, {
+						ascending: clause.direction === "asc",
+						...clause.nulls ? { nullsFirst: clause.nulls === "first" } : {}
+					});
+					const { data, error } = await query.range(input.offset, rangeEnd);
+					throwSupabaseError("findMany bundle_events", error);
+					return data ?? [];
+				}
+				case "api_keys": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.apiKeys).select("*");
+					if (filter !== void 0) query = query.or(filter);
+					for (const clause of orderBy) query = query.order(clause.field, {
+						ascending: clause.direction === "asc",
+						...clause.nulls ? { nullsFirst: clause.nulls === "first" } : {}
+					});
+					const { data, error } = await query.range(input.offset, rangeEnd);
+					throwSupabaseError("findMany api_keys", error);
+					return data ?? [];
+				}
+				case "bundle_patches": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.bundlePatches).select("*");
+					if (filter !== void 0) query = query.or(filter);
+					for (const clause of orderBy) query = query.order(clause.field, {
+						ascending: clause.direction === "asc",
+						...clause.nulls ? { nullsFirst: clause.nulls === "first" } : {}
+					});
+					const { data, error } = await query.range(input.offset, rangeEnd);
+					throwSupabaseError("findMany bundle_patches", error);
+					return data ?? [];
+				}
+				case "channels": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.channels).select("*");
+					if (filter !== void 0) query = query.or(filter);
+					for (const clause of orderBy) query = query.order(clause.field, {
+						ascending: clause.direction === "asc",
+						...clause.nulls ? { nullsFirst: clause.nulls === "first" } : {}
+					});
+					const { data, error } = await query.range(input.offset, rangeEnd);
+					throwSupabaseError("findMany channels", error);
+					return data ?? [];
+				}
+				case "releases": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.releases).select("*");
+					if (filter !== void 0) query = query.or(filter);
+					for (const clause of orderBy) query = query.order(clause.field, {
+						ascending: clause.direction === "asc",
+						...clause.nulls ? { nullsFirst: clause.nulls === "first" } : {}
+					});
+					const { data, error } = await query.range(input.offset, rangeEnd);
+					throwSupabaseError("findMany releases", error);
+					return data ?? [];
+				}
+				case "release_catalogs": {
+					let query = supabase.from(SUPABASE_V1_TABLE_NAMES.releaseCatalogs).select("*");
+					if (filter !== void 0) query = query.or(filter);
+					for (const clause of orderBy) query = query.order(clause.field, {
+						ascending: clause.direction === "asc",
+						...clause.nulls ? { nullsFirst: clause.nulls === "first" } : {}
+					});
+					const { data, error } = await query.range(input.offset, rangeEnd);
+					throwSupabaseError("findMany release_catalogs", error);
+					return data ?? [];
+				}
+			}
+		},
+		async insertChannel(input) {
+			const { data: inserted, error: insertError } = await supabase.from(SUPABASE_V1_TABLE_NAMES.channels).upsert(input.row, {
+				onConflict: "name",
+				ignoreDuplicates: true
+			}).select("*").maybeSingle();
+			throwSupabaseError("insert channel", insertError);
+			if (inserted !== null) return {
+				row: inserted,
+				inserted: true
+			};
+			const { data: existing, error: findError } = await supabase.from(SUPABASE_V1_TABLE_NAMES.channels).select("*").eq("name", input.row.name).single();
+			throwSupabaseError("find canonical channel", findError);
+			if (existing === null) throw new SupabaseMissingDataError("find canonical channel");
+			return {
+				row: existing,
+				inserted: false
+			};
+		},
+		async deleteChannel(input) {
+			const { data, error } = await supabase.rpc(SUPABASE_V1_FUNCTION_NAMES.deleteChannel, { p_id: input.id });
+			throwSupabaseError("delete channel", error);
+			if (data === null || typeof data !== "object" || !("deleted" in data) || typeof data.deleted !== "boolean") throw new SupabaseMissingDataError("delete channel");
+			return data;
+		}
+	};
+	implementation.commit = async (input) => {
+		const { data, error } = await supabase.rpc(SUPABASE_V1_FUNCTION_NAMES.commit, { p_commit: input });
+		throwSupabaseError("commit database changes", error);
+		if (data === null || typeof data !== "object" || !("committed" in data) || typeof data.committed !== "boolean") throw new SupabaseMissingDataError("commit database changes");
+		return data;
+	};
+	return implementation;
+};
+const supabaseDatabase = (config) => {
+	const adapter = (0, _hot_updater_plugin_core_internal.createDatabasePluginAdapter)("supabaseDatabase", createSupabaseImplementation((0, _supabase_supabase_js.createClient)(config.supabaseUrl, resolveSupabaseServiceRoleKey(config))));
+	return (0, _hot_updater_plugin_core.createDatabasePlugin)({
+		name: "supabaseDatabase",
+		models: adapter.models,
+		commit: adapter.commit
+	});
+};
+//#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/supabaseStorage.ts
+const isNotFoundError = (error) => error?.message?.toLowerCase().includes("not found") === true;
+const isMissingExistsError = (error) => {
+	if (typeof error !== "object" || error === null || Reflect.get(error, "name") !== "StorageUnknownError") return false;
+	const originalError = Reflect.get(error, "originalError");
+	if (typeof originalError !== "object" || originalError === null) return false;
+	const status = Reflect.get(originalError, "status");
+	return status === 400 || status === 404;
+};
+const supabaseStorage = (config) => {
+	const bucket = (0, _supabase_supabase_js.createClient)(config.supabaseUrl, resolveSupabaseServiceRoleKey(config)).storage.from(config.bucketName);
+	const getStorageKey = (0, _hot_updater_plugin_core.createStorageKeyBuilder)(config.basePath);
+	const resolveSignedUrl = createSupabaseSignedUrlBatcher({
+		createSignedUrls: (_bucketName, keys, expiresIn) => bucket.createSignedUrls(keys, expiresIn),
+		expiresIn: config.signedUrlExpiresIn ?? 3600,
+		formatObjectPath: (_bucketName, key) => key
+	});
+	const parseAndValidate = (storageUri) => {
+		const parsed = (0, _hot_updater_plugin_core.parseStorageUri)(storageUri, "supabase-storage");
+		if (parsed.bucket !== config.bucketName) throw new Error(`Bucket name mismatch: expected "${config.bucketName}", but found "${parsed.bucket}".`);
+		return parsed;
+	};
+	return (0, _hot_updater_plugin_core.createStoragePlugin)({
+		name: "supabaseStorage",
+		protocol: "supabase-storage",
+		async put({ key, body, contentLength, contentType }) {
+			const storageKey = getStorageKey(key);
+			const { error } = await bucket.upload(storageKey, body, {
+				contentType,
+				cacheControl: "max-age=31536000",
+				duplex: "half",
+				...contentLength === void 0 ? {} : { headers: { "content-length": String(contentLength) } }
+			});
+			if (error) throw error;
+			return { storageUri: (0, _hot_updater_plugin_core.createStorageUri)({
+				protocol: "supabase-storage",
+				bucket: config.bucketName,
+				key: storageKey
+			}) };
+		},
+		async get({ storageUri }) {
+			const { key } = parseAndValidate(storageUri);
+			const { data, error } = await bucket.download(key);
+			if (error) {
+				if (isNotFoundError(error)) return { response: null };
+				throw new Error(`Failed to download storage object: ${error.message}`);
+			}
+			return { response: data ? new Response(data) : null };
+		},
+		async getDownloadUrl({ storageUri }) {
+			const { key } = parseAndValidate(storageUri);
+			return { url: await resolveSignedUrl(config.bucketName, key) };
+		},
+		async exists({ storageUri }) {
+			const { key } = parseAndValidate(storageUri);
+			const { data, error } = await bucket.exists(key);
+			if (error) {
+				if (isMissingExistsError(error)) return { exists: false };
+				throw error;
+			}
+			return { exists: data };
+		},
+		async delete({ storageUri }) {
+			const { key } = parseAndValidate(storageUri);
+			const { error } = await bucket.remove([key]);
+			if (error && !isNotFoundError(error)) throw new Error(`Failed to delete storage object: ${error.message}`);
+			return { deleted: true };
+		}
+	});
+};
+//#endregion
+Object.defineProperty(exports, "supabaseDatabase", {
+	enumerable: true,
+	get: function() {
+		return supabaseDatabase;
+	}
+});
+Object.defineProperty(exports, "supabaseStorage", {
+	enumerable: true,
+	get: function() {
+		return supabaseStorage;
+	}
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hot-updater/supabase",
   "type": "module",
-  "version": "0.36.7",
+  "version": "1.0.0-rc.0",
   "description": "React Native OTA solution for self-hosted",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -17,6 +17,7 @@
       "require": "./dist/init/index.cjs"
     },
     "./edge": {
+      "types": "./dist/edge.d.cts",
       "import": "./dist/edge.mjs",
       "require": "./dist/edge.cjs"
     },
@@ -55,10 +56,10 @@
     "@supabase/supabase-js": "2.76.1",
     "hono": "4.12.34",
     "uuidv7": "^1.0.2",
-    "@hot-updater/core": "0.36.7",
-    "@hot-updater/cli-tools": "0.36.7",
-    "@hot-updater/plugin-core": "0.36.7",
-    "@hot-updater/server": "0.36.7"
+    "@hot-updater/core": "1.0.0-rc.0",
+    "@hot-updater/server": "1.0.0-rc.0",
+    "@hot-updater/cli-tools": "1.0.0-rc.0",
+    "@hot-updater/plugin-core": "1.0.0-rc.0"
   },
   "devDependencies": {
     "@electric-sql/pglite": "0.4.1",
@@ -68,10 +69,9 @@
     "execa": "9.5.2",
     "@types/node": "^20",
     "mime": "^4.0.4",
-    "@hot-updater/js": "0.36.7",
-    "@hot-updater/mock": "0.36.7",
-    "@hot-updater/test-utils": "0.36.7",
-    "@hot-updater/postgres": "0.36.7"
+    "@hot-updater/mock": "1.0.0-rc.0",
+    "@hot-updater/postgres": "1.0.0-rc.0",
+    "@hot-updater/test-utils": "1.0.0-rc.0"
   },
   "scripts": {
     "build": "tsdown",

package/supabase/edge-functions/index.ts

@@ -1,44 +1,40 @@
 import "jsr:@supabase/functions-js/edge-runtime.d.ts";
 import { createHotUpdater } from "@hot-updater/server";
-import {
-  supabaseEdgeFunctionDatabase,
-  supabaseEdgeFunctionStorage,
-} from "@hot-updater/supabase";
+import { supabaseDatabase, supabaseStorage } from "@hot-updater/supabase/edge";
 import { Hono } from "hono";
 
 declare global {
   var HotUpdater: {
+    BUCKET_NAME: string;
     FUNCTION_NAME: string;
   };
 }
 
 const functionName = HotUpdater.FUNCTION_NAME;
+const bucketName = HotUpdater.BUCKET_NAME;
 const supabaseUrl = Deno.env.get("SUPABASE_URL") ?? "";
 const supabaseServiceRoleKey = Deno.env.get("SUPABASE_SERVICE_ROLE_KEY") ?? "";
 const functionBasePath = `/${functionName}`;
 const hotUpdaterBasePath = "/";
 
 const hotUpdater = createHotUpdater({
-  database: supabaseEdgeFunctionDatabase({
+  database: supabaseDatabase({
     supabaseUrl,
     supabaseServiceRoleKey,
   }),
-  storages: [
-    supabaseEdgeFunctionStorage({
+  clientAccess: { type: "api-key" },
+  storage: [
+    supabaseStorage({
       supabaseUrl,
       supabaseServiceRoleKey,
+      bucketName,
     }),
   ],
-  basePath: hotUpdaterBasePath,
-  routes: {
-    updateCheck: true,
-    bundles: false,
-  },
 });
 
 const app = new Hono().basePath(functionBasePath);
 
 app.get("/ping", (c) => c.text("pong"));
-app.mount(hotUpdaterBasePath, hotUpdater.handler);
+app.mount(hotUpdaterBasePath, hotUpdater.handlers.client);
 
 Deno.serve(app.fetch);