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

package/supabase/migrations.spec.ts

@@ -1,67 +1,148 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 
+import { PGlite } from "@electric-sql/pglite";
 import { describe, expect, it } from "vitest";
 
-const rlsMigrationPath = path.resolve(
-  "plugins/supabase/supabase/migrations/20260520014100_hot-updater_rls.sql",
+const migrationPath = path.resolve(
+  "plugins/supabase/supabase/migrations/20260818000000_hot-updater_1.0.0.sql",
 );
-const migrationsDir = path.dirname(rlsMigrationPath);
 
-describe("Supabase RLS migration", () => {
-  it("runs after Supabase function redefinition migrations", async () => {
-    const migrations = (await fs.readdir(migrationsDir))
-      .filter((file) => file.endsWith(".sql"))
-      .sort();
+const readMigrations = async () => {
+  const migrationDirectory = path.resolve(
+    "plugins/supabase/supabase/migrations",
+  );
+  const migrationFiles = (await fs.readdir(migrationDirectory))
+    .filter((file) => file.endsWith(".sql"))
+    .sort();
+  return Promise.all(
+    migrationFiles.map(async (file) => ({
+      file,
+      sql: await fs.readFile(path.join(migrationDirectory, file), "utf8"),
+    })),
+  );
+};
 
-    expect(migrations.at(-1)).toBe(path.basename(rlsMigrationPath));
+describe("Supabase v1 schema", () => {
+  it("ships a single 1.0.0 CREATE migration", async () => {
+    const migrations = await readMigrations();
+    expect(migrations.map(({ file }) => file)).toEqual([
+      "20260818000000_hot-updater_1.0.0.sql",
+    ]);
   });
 
-  it("enables RLS on Hot Updater tables", async () => {
-    const sql = await fs.readFile(rlsMigrationPath, "utf8");
+  it("creates namespaced tables, RLS, and functions", async () => {
+    const sql = await fs.readFile(migrationPath, "utf8");
 
+    expect(sql).toContain("CREATE TABLE public.hot_updater_v1_channels");
+    expect(sql).toContain("CREATE TABLE public.hot_updater_v1_bundles");
+    expect(sql).toContain("CREATE TABLE public.hot_updater_v1_releases");
     expect(sql).toContain(
-      "ALTER TABLE public.bundles ENABLE ROW LEVEL SECURITY;",
+      "CREATE TABLE public.hot_updater_v1_release_catalogs",
     );
+    expect(sql).toContain("CREATE TABLE public.hot_updater_v1_bundle_events");
+    expect(sql).toContain("CREATE TABLE public.hot_updater_v1_api_keys");
     expect(sql).toContain(
-      "ALTER TABLE public.bundle_patches ENABLE ROW LEVEL SECURITY;",
+      "ALTER TABLE public.hot_updater_v1_bundles ENABLE ROW LEVEL SECURITY",
     );
-    expect(sql).not.toContain("REVOKE ALL ON TABLE");
-    expect(sql).not.toContain("GRANT SELECT, INSERT, UPDATE, DELETE");
-  });
-
-  it("pins search_path for public Hot Updater functions", async () => {
-    const sql = await fs.readFile(rlsMigrationPath, "utf8");
-    const hotUpdaterFunctions = [
-      "get_target_app_version_list",
-      "get_channels",
-      "positive_mod",
-      "hash_rollout_value",
-      "normalize_cohort_value",
-      "gcd_int",
-      "get_rollout_multiplier",
-      "get_rollout_offset",
-      "get_modular_inverse",
-      "is_numeric_cohort",
-      "get_numeric_cohort_rollout_position",
-      "is_cohort_eligible",
-      "get_update_info_by_fingerprint_hash",
-      "get_update_info_by_app_version",
-    ];
-
-    for (const functionName of hotUpdaterFunctions) {
-      expect(sql).toContain(`ALTER FUNCTION public.${functionName}`);
-    }
-
-    expect(sql.match(/SET search_path = public, pg_catalog;/g)).toHaveLength(
-      hotUpdaterFunctions.length,
+    expect(sql).toContain(
+      "CREATE FUNCTION public.hot_updater_v1_commit(p_commit jsonb)",
     );
+    expect(sql).toContain(
+      "CREATE FUNCTION public.hot_updater_v1_delete_channel(p_id text)",
+    );
+    expect(sql).toContain("REVOKE EXECUTE ON FUNCTION");
+    expect(sql).toContain("TO service_role;");
+    expect(sql).toContain("archive_byte_size double precision NOT NULL CHECK");
+    expect(sql).toContain("byte_size double precision NOT NULL CHECK");
+    expect(sql).toContain("archive_byte_size = v_bundle.archive_byte_size");
+    expect(sql).toContain(
+      "patch_file_hash, patch_storage_uri, byte_size, order_index",
+    );
+    expect(sql).toContain("NOTIFY pgrst, 'reload schema'");
+    expect(sql).not.toContain("get_update_info");
+    expect(sql).not.toContain("ALTER TABLE public.bundles ADD COLUMN");
   });
 
-  it("does not change function execution grants", async () => {
-    const sql = await fs.readFile(rlsMigrationPath, "utf8");
+  it("applies beside a v0 schema without modifying v0 data", async () => {
+    const database = new PGlite();
+    try {
+      await database.exec(
+        "CREATE ROLE anon; CREATE ROLE authenticated; CREATE ROLE service_role;",
+      );
+      await database.exec(`
+        CREATE TABLE public.channels (id text PRIMARY KEY, name text NOT NULL);
+        CREATE TABLE public.bundles (
+          id uuid PRIMARY KEY,
+          target_app_version text NOT NULL
+        );
+        INSERT INTO public.channels (id, name)
+          VALUES ('legacy-channel', 'legacy');
+        INSERT INTO public.bundles (id, target_app_version)
+          VALUES ('00000000-0000-0000-0000-000000000099', '0.85.0');
+      `);
+      for (const migration of await readMigrations()) {
+        await database.exec(migration.sql);
+      }
+
+      const tables = await database.query<{ tablename: string }>(`
+        select tablename from pg_tables
+        where schemaname = 'public'
+        order by tablename
+      `);
+      expect(tables.rows.map(({ tablename }) => tablename)).toEqual(
+        expect.arrayContaining([
+          "hot_updater_v1_bundles",
+          "hot_updater_v1_bundle_events",
+          "hot_updater_v1_bundle_patches",
+          "hot_updater_v1_channels",
+          "hot_updater_v1_api_keys",
+          "hot_updater_v1_private_settings",
+          "hot_updater_v1_release_catalogs",
+          "hot_updater_v1_releases",
+        ]),
+      );
 
-    expect(sql).not.toContain("REVOKE EXECUTE");
-    expect(sql).not.toContain("GRANT EXECUTE");
+      await database.exec(`
+        INSERT INTO public.hot_updater_v1_channels (id, name)
+          VALUES ('channel-1', 'production');
+        INSERT INTO public.hot_updater_v1_bundles (
+          id, platform, file_hash, storage_uri, archive_byte_size, metadata
+        ) VALUES (
+          '00000000-0000-0000-0000-000000000001', 'ios', 'hash',
+          'storage://bundle', 3000000001, '{}'::jsonb
+        );
+        INSERT INTO public.hot_updater_v1_bundle_patches (
+          id, bundle_id, base_bundle_id, base_file_hash, patch_file_hash,
+          patch_storage_uri, byte_size
+        ) VALUES (
+          'patch-1', '00000000-0000-0000-0000-000000000001',
+          '00000000-0000-0000-0000-000000000001', 'base-hash', 'patch-hash',
+          'storage://patch', 3000000002
+        );
+      `);
+      const channels = await database.query<{ name: string }>(
+        "SELECT name FROM public.hot_updater_v1_channels",
+      );
+      expect(channels.rows).toEqual([{ name: "production" }]);
+      const legacyChannels = await database.query<{ name: string }>(
+        "SELECT name FROM public.channels",
+      );
+      expect(legacyChannels.rows).toEqual([{ name: "legacy" }]);
+      const sizes = await database.query<{
+        archive_byte_size: number;
+        byte_size: number;
+      }>(`
+        SELECT bundle.archive_byte_size, patch.byte_size
+        FROM public.hot_updater_v1_bundles AS bundle
+        JOIN public.hot_updater_v1_bundle_patches AS patch
+          ON patch.bundle_id = bundle.id
+      `);
+      expect(sizes.rows).toEqual([
+        { archive_byte_size: 3_000_000_001, byte_size: 3_000_000_002 },
+      ]);
+    } finally {
+      await database.close();
+    }
   });
 });

package/dist/supabaseEdgeFunctionStorage-BRxGvt-r.d.mts

@@ -1,19 +0,0 @@
-import * as _$_hot_updater_plugin_core0 from "@hot-updater/plugin-core";
-import { DatabasePluginHooks } from "@hot-updater/plugin-core";
-
-//#region src/supabaseEdgeFunctionDatabase.d.ts
-interface SupabaseEdgeFunctionDatabaseConfig {
-  supabaseUrl: string;
-  supabaseServiceRoleKey: string;
-}
-declare const supabaseEdgeFunctionDatabase: (config: SupabaseEdgeFunctionDatabaseConfig, hooks?: DatabasePluginHooks) => () => _$_hot_updater_plugin_core0.DatabasePlugin<unknown>;
-//#endregion
-//#region src/supabaseEdgeFunctionStorage.d.ts
-interface SupabaseEdgeFunctionStorageConfig {
-  supabaseUrl: string;
-  supabaseServiceRoleKey: string;
-  signedUrlExpiresIn?: number;
-}
-declare const supabaseEdgeFunctionStorage: (config: SupabaseEdgeFunctionStorageConfig, hooks?: _$_hot_updater_plugin_core0.StoragePluginHooks) => () => _$_hot_updater_plugin_core0.RuntimeStoragePlugin<unknown>;
-//#endregion
-export { supabaseEdgeFunctionDatabase as i, supabaseEdgeFunctionStorage as n, SupabaseEdgeFunctionDatabaseConfig as r, SupabaseEdgeFunctionStorageConfig as t };

package/dist/supabaseEdgeFunctionStorage-BSLlUeqi.cjs

@@ -1,386 +0,0 @@
-require("./index.cjs");
-let _hot_updater_core = require("@hot-updater/core");
-let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
-let _supabase_supabase_js = require("@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: (0, _hot_updater_core.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 ?? _hot_updater_core.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: (0, _hot_updater_core.stripBundleArtifactMetadata)(bundle.metadata) ?? {},
-	manifest_storage_uri: (0, _hot_updater_core.getManifestStorageUri)(bundle),
-	manifest_file_hash: (0, _hot_updater_core.getManifestFileHash)(bundle),
-	asset_base_storage_uri: (0, _hot_updater_core.getAssetBaseStorageUri)(bundle),
-	rollout_cohort_count: bundle.rolloutCohortCount ?? _hot_updater_core.DEFAULT_ROLLOUT_COHORT_COUNT,
-	target_cohorts: bundle.targetCohorts ?? null
-});
-const bundleToPatchRows = (bundle) => (0, _hot_updater_core.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 = (0, _hot_updater_plugin_core.createDatabasePlugin)({
-	name: "supabaseDatabase",
-	factory: (config) => {
-		const supabase = (0, _supabase_supabase_js.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 ?? _hot_updater_core.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 = (0, _hot_updater_plugin_core.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: (0, _hot_updater_plugin_core.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: (0, _hot_updater_plugin_core.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 } = (0, _hot_updater_plugin_core.parseStorageUri)(storageUri, "supabase-storage");
-	if (!bucketName || !key) throw new Error("Invalid Supabase storage URI");
-	return {
-		bucketName,
-		key
-	};
-};
-const supabaseEdgeFunctionStorage = (0, _hot_updater_plugin_core.createRuntimeStoragePlugin)({
-	name: "supabaseEdgeFunctionStorage",
-	supportedProtocol: "supabase-storage",
-	factory: (config) => {
-		const supabase = (0, _supabase_supabase_js.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
-Object.defineProperty(exports, "createSupabaseSignedUrlBatcher", {
-	enumerable: true,
-	get: function() {
-		return createSupabaseSignedUrlBatcher;
-	}
-});
-Object.defineProperty(exports, "resolveSupabaseServiceRoleKey", {
-	enumerable: true,
-	get: function() {
-		return resolveSupabaseServiceRoleKey;
-	}
-});
-Object.defineProperty(exports, "supabaseDatabase", {
-	enumerable: true,
-	get: function() {
-		return supabaseDatabase;
-	}
-});
-Object.defineProperty(exports, "supabaseEdgeFunctionDatabase", {
-	enumerable: true,
-	get: function() {
-		return supabaseEdgeFunctionDatabase;
-	}
-});
-Object.defineProperty(exports, "supabaseEdgeFunctionStorage", {
-	enumerable: true,
-	get: function() {
-		return supabaseEdgeFunctionStorage;
-	}
-});

package/dist/supabaseEdgeFunctionStorage-CU396KO3.d.cts

@@ -1,19 +0,0 @@
-import * as _$_hot_updater_plugin_core0 from "@hot-updater/plugin-core";
-import { DatabasePluginHooks } from "@hot-updater/plugin-core";
-
-//#region src/supabaseEdgeFunctionDatabase.d.ts
-interface SupabaseEdgeFunctionDatabaseConfig {
-  supabaseUrl: string;
-  supabaseServiceRoleKey: string;
-}
-declare const supabaseEdgeFunctionDatabase: (config: SupabaseEdgeFunctionDatabaseConfig, hooks?: DatabasePluginHooks) => () => _$_hot_updater_plugin_core0.DatabasePlugin<unknown>;
-//#endregion
-//#region src/supabaseEdgeFunctionStorage.d.ts
-interface SupabaseEdgeFunctionStorageConfig {
-  supabaseUrl: string;
-  supabaseServiceRoleKey: string;
-  signedUrlExpiresIn?: number;
-}
-declare const supabaseEdgeFunctionStorage: (config: SupabaseEdgeFunctionStorageConfig, hooks?: _$_hot_updater_plugin_core0.StoragePluginHooks) => () => _$_hot_updater_plugin_core0.RuntimeStoragePlugin<unknown>;
-//#endregion
-export { supabaseEdgeFunctionDatabase as i, supabaseEdgeFunctionStorage as n, SupabaseEdgeFunctionDatabaseConfig as r, SupabaseEdgeFunctionStorageConfig as t };