better-supabase 0.5.0 → 0.6.0

package/dist/client/native/index.js

@@ -0,0 +1,361 @@
+import { n as dbError } from "../../errors-B11Duf73.js";
+import { r as err, s as toDbError, t as AsyncResult } from "../../result-DzUbqgdW.js";
+import { i as toBase64, r as fromBase64 } from "../../base64-D2gsioCY.js";
+import { t as bindClient } from "../../bind-l4kAvYSv.js";
+import { n as linkParams, r as signInWithOAuthBrowser, t as handleAuthDeepLink } from "../../auth-link-DrDX9KOT.js";
+//#region src/client/native/auto-refresh.ts
+/**
+* Refreshes the Supabase session only while the app is in the foreground,
+* as supabase-js requires on React Native. Returns a function that removes
+* the listener and stops refreshing.
+*
+* ```ts
+* import { AppState } from 'react-native';
+* autoRefreshOnForeground(supabase, AppState);
+* ```
+*/
+function autoRefreshOnForeground(supabase, appState) {
+	const apply = (state) => {
+		if (state === "active") supabase.auth.startAutoRefresh();
+		else supabase.auth.stopAutoRefresh();
+	};
+	if (appState.currentState === "active") apply("active");
+	const subscription = appState.addEventListener("change", apply);
+	return () => {
+		subscription.remove();
+		supabase.auth.stopAutoRefresh();
+	};
+}
+//#endregion
+//#region src/client/native/key-value.ts
+function isMmkv(store) {
+	return "getString" in store;
+}
+function keyValue(store) {
+	if (!isMmkv(store)) return {
+		get: (key) => store.getItem(key),
+		set: (key, value) => store.setItem(key, value),
+		remove: (key) => store.removeItem(key)
+	};
+	return {
+		get: (key) => Promise.resolve(store.getString(key) ?? null),
+		set: (key, value) => {
+			store.set(key, value);
+			return Promise.resolve();
+		},
+		remove: (key) => {
+			if (store.remove) store.remove(key);
+			else store.delete?.(key);
+			return Promise.resolve();
+		}
+	};
+}
+//#endregion
+//#region src/client/native/storage.ts
+const UNSAFE = /[^\w.-]/g;
+/** FNV-1a, enough to tell apart keys that map to the same safe name. */
+function hashOf(text) {
+	let hash = 2166136261;
+	for (const char of text) {
+		hash ^= char.codePointAt(0) ?? 0;
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+/**
+* expo-secure-store keys allow letters, digits, `.`, `-` and `_` only. A key
+* that needs no change keeps its name (sessions stored before stay
+* readable); one that does gets a hash suffix, so `a:b` and `a/b` differ.
+*/
+function safeKey(key) {
+	const safe = key.replaceAll(UNSAFE, "_");
+	return safe === key ? key : `${safe}-${hashOf(key)}`;
+}
+/** `<count>` or `<count>b` in `<key>.chunks`. */
+const POINTER = /^([1-9]\d*)(b?)$/;
+/**
+* Supabase Auth storage on the device keychain (`expo-secure-store`),
+* split into chunks so sessions above the platform's value size fit.
+* Operations on one key run one at a time, and a write moves the pointer
+* only after every chunk is stored, so a reader never joins chunks of two
+* values and a write that fails part way keeps the previous value.
+*
+* ```ts
+* import * as SecureStore from 'expo-secure-store';
+* createClient(url, key, { auth: { storage: secureStorage(SecureStore) } });
+* ```
+*/
+function secureStorage(store, options = {}) {
+	const size = options.chunkSize ?? 1800;
+	const extra = options.storeOptions;
+	const get = (key) => extra ? store.getItemAsync(key, extra) : store.getItemAsync(key);
+	const set = (key, value) => extra ? store.setItemAsync(key, value, extra) : store.setItemAsync(key, value);
+	const remove = (key) => extra ? store.deleteItemAsync(key, extra) : store.deleteItemAsync(key);
+	if (!Number.isInteger(size) || size < 1) throw new TypeError("better-supabase: chunkSize must be a positive integer");
+	const countKey = (key) => `${safeKey(key)}.chunks`;
+	const chunkKey = (key, slot, index) => `${safeKey(key)}.${index}${slot}`;
+	const pointerOf = async (key) => {
+		const raw = await get(countKey(key));
+		const match = raw === null ? null : POINTER.exec(raw);
+		return match ? {
+			count: Number(match[1]),
+			slot: match[2] === "b" ? "b" : ""
+		} : {
+			count: 0,
+			slot: "b"
+		};
+	};
+	const removeChunks = async (key, slot, count) => {
+		await Promise.all(Array.from({ length: count }, (_, index) => remove(chunkKey(key, slot, index))));
+	};
+	const queues = /* @__PURE__ */ new Map();
+	/** Runs `task` after every earlier operation on `key` settled. */
+	const serial = (key, task) => {
+		const run = (queues.get(key) ?? Promise.resolve()).then(task);
+		const settled = run.then(() => void 0, () => void 0);
+		queues.set(key, settled);
+		settled.then(() => {
+			if (queues.get(key) === settled) queues.delete(key);
+		});
+		return run;
+	};
+	return {
+		getItem: (key) => serial(key, async () => {
+			const { count, slot } = await pointerOf(key);
+			if (count === 0) return null;
+			const chunks = await Promise.all(Array.from({ length: count }, (_, index) => get(chunkKey(key, slot, index))));
+			if (chunks.some((chunk) => chunk === null)) return null;
+			return chunks.join("");
+		}),
+		setItem: (key, value) => serial(key, async () => {
+			const chunks = [];
+			for (let start = 0; start < value.length; start += size) chunks.push(value.slice(start, start + size));
+			if (chunks.length === 0) chunks.push("");
+			const previous = await pointerOf(key);
+			const slot = previous.slot === "b" ? "" : "b";
+			await Promise.all(chunks.map((chunk, index) => set(chunkKey(key, slot, index), chunk)));
+			await set(countKey(key), `${chunks.length}${slot}`);
+			await removeChunks(key, previous.slot, previous.count);
+		}),
+		removeItem: (key) => serial(key, async () => {
+			const previous = await pointerOf(key);
+			await remove(countKey(key));
+			await removeChunks(key, previous.slot, previous.count);
+		})
+	};
+}
+//#endregion
+//#region src/client/native/large-storage.ts
+const VERSION = "v1";
+const IV_BYTES = 12;
+function globalCrypto() {
+	const { crypto } = globalThis;
+	return crypto?.subtle && crypto.getRandomValues ? crypto : void 0;
+}
+/**
+* Supabase Auth storage for sessions of any size: the session is encrypted
+* with AES-GCM and kept in MMKV or AsyncStorage, and only its key lives in
+* the keychain. A key that no longer decrypts (the app was reinstalled and
+* one store kept its data) reads as signed out and is replaced on the next
+* sign-in.
+*
+* ```ts
+* import * as SecureStore from 'expo-secure-store';
+* import AsyncStorage from '@react-native-async-storage/async-storage';
+* createClient(url, key, { auth: { storage: largeSecureStorage({ secureStore: SecureStore, storage: AsyncStorage }) } });
+* ```
+*/
+function largeSecureStorage(options) {
+	const store = keyValue(options.storage);
+	const secure = options.secureStore;
+	const extra = options.storeOptions;
+	const keyName = (key) => `${safeKey(key)}.aes`;
+	const getSecret = (key) => extra ? secure.getItemAsync(keyName(key), extra) : secure.getItemAsync(keyName(key));
+	const setSecret = (key, value) => extra ? secure.setItemAsync(keyName(key), value, extra) : secure.setItemAsync(keyName(key), value);
+	const removeSecret = (key) => extra ? secure.deleteItemAsync(keyName(key), extra) : secure.deleteItemAsync(keyName(key));
+	const cryptoOf = () => {
+		const found = options.crypto ?? globalCrypto();
+		if (!found) throw new Error("better-supabase: largeSecureStorage needs WebCrypto; pass { crypto } from react-native-quick-crypto");
+		return found;
+	};
+	const importKey = (raw) => cryptoOf().subtle.importKey("raw", raw, "AES-GCM", false, ["encrypt", "decrypt"]);
+	return {
+		async getItem(key) {
+			const [secret, sealed] = await Promise.all([getSecret(key), store.get(key)]);
+			if (secret === null || sealed === null) return null;
+			const [version, iv, data] = sealed.split(".");
+			if (version !== VERSION || iv === void 0 || data === void 0) return null;
+			try {
+				const plain = await cryptoOf().subtle.decrypt({
+					name: "AES-GCM",
+					iv: fromBase64(iv)
+				}, await importKey(fromBase64(secret)), fromBase64(data));
+				return new TextDecoder().decode(plain);
+			} catch {
+				return null;
+			}
+		},
+		async setItem(key, value) {
+			const crypto = cryptoOf();
+			const raw = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(32));
+			const iv = crypto.getRandomValues(new Uint8Array(IV_BYTES));
+			const sealed = await crypto.subtle.encrypt({
+				name: "AES-GCM",
+				iv
+			}, await importKey(raw), new TextEncoder().encode(value));
+			await setSecret(key, toBase64(raw));
+			await store.set(key, `${VERSION}.${toBase64(iv)}.${toBase64(new Uint8Array(sealed))}`);
+		},
+		async removeItem(key) {
+			await Promise.all([store.remove(key), removeSecret(key)]);
+		}
+	};
+}
+//#endregion
+//#region src/client/native/persist.ts
+/**
+* Persists the query cache to MMKV or AsyncStorage, so a cold start shows
+* the last rows before the first fetch. The provider's `clearOnUserChange`
+* drops them when another user signs in.
+*
+* ```tsx
+* <PersistQueryClientProvider client={queryClient} persistOptions={{ persister: persistQueryCache(storage) }}>
+* ```
+*/
+function persistQueryCache(storage, options = {}) {
+	const store = keyValue(storage);
+	const key = options.key ?? "better-supabase.query-cache";
+	const throttleMs = options.throttleMs ?? 1e3;
+	let pending;
+	let timer;
+	let writing = Promise.resolve();
+	const flush = () => {
+		timer = void 0;
+		const next = pending;
+		pending = void 0;
+		if (!next) return writing;
+		writing = writing.then(() => store.set(key, next.value));
+		return writing;
+	};
+	return {
+		persistClient(client) {
+			pending = { value: JSON.stringify(client) };
+			timer ??= setTimeout(() => void flush(), throttleMs);
+			return Promise.resolve();
+		},
+		async restoreClient() {
+			const raw = await store.get(key);
+			let restored;
+			if (raw !== null) try {
+				restored = JSON.parse(raw);
+			} catch {}
+			return restored;
+		},
+		async removeClient() {
+			if (timer !== void 0) clearTimeout(timer);
+			timer = void 0;
+			pending = void 0;
+			await writing;
+			await store.remove(key);
+		}
+	};
+}
+//#endregion
+//#region src/client/native/query.ts
+const NOOP = () => void 0;
+/**
+* Wires TanStack Query to the app lifecycle on React Native: queries count
+* as focused while the app is active, and as online while NetInfo reports
+* a connection (an unreachable internet counts as offline). Returns a
+* function that removes every listener.
+*
+* ```ts
+* import { focusManager, onlineManager } from '@tanstack/react-query';
+* import NetInfo from '@react-native-community/netinfo';
+* import { AppState } from 'react-native';
+* syncQueryWithApp({ focusManager, onlineManager, appState: AppState, netInfo: NetInfo, supabase });
+* ```
+*/
+function syncQueryWithApp(options) {
+	const { focusManager, onlineManager, appState, netInfo, supabase } = options;
+	focusManager.setEventListener((setFocused) => {
+		setFocused(appState.currentState === "active");
+		const subscription = appState.addEventListener("change", (state) => {
+			setFocused(state === "active");
+		});
+		return () => {
+			subscription.remove();
+		};
+	});
+	if (onlineManager && netInfo) onlineManager.setEventListener((setOnline) => netInfo.addEventListener((state) => {
+		setOnline(state.isConnected === true && state.isInternetReachable !== false);
+	}));
+	const stopRefresh = supabase ? autoRefreshOnForeground(supabase, appState) : void 0;
+	return () => {
+		focusManager.setEventListener(NOOP);
+		if (onlineManager && netInfo) onlineManager.setEventListener(NOOP);
+		stopRefresh?.();
+	};
+}
+//#endregion
+//#region src/client/native/upload.ts
+const TYPES = {
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	png: "image/png",
+	gif: "image/gif",
+	webp: "image/webp",
+	heic: "image/heic",
+	heif: "image/heif",
+	mp4: "video/mp4",
+	mov: "video/quicktime",
+	m4a: "audio/mp4",
+	mp3: "audio/mpeg",
+	pdf: "application/pdf",
+	json: "application/json",
+	txt: "text/plain",
+	csv: "text/csv"
+};
+/** The content type for a file URI's extension, ignoring a query or fragment. */
+function contentTypeOf(uri) {
+	const path = uri.split(/[?#]/, 1)[0] ?? uri;
+	const dot = path.lastIndexOf(".");
+	if (dot === -1 || dot < path.lastIndexOf("/")) return void 0;
+	return TYPES[path.slice(dot + 1).toLowerCase()];
+}
+/**
+* Uploads a local file (an `expo-image-picker` or `expo-document-picker`
+* URI) to a connected bucket. The file is read into an `ArrayBuffer`, as
+* React Native's `Blob` can't be uploaded; the content type comes from the
+* option, the response or the extension.
+*
+* ```ts
+* const picked = await ImagePicker.launchImageLibraryAsync();
+* await uploadFromUri(avatars, { userId }, picked.assets[0].uri, { upsert: true });
+* ```
+*/
+function uploadFromUri(bucket, target, uri, options = {}) {
+	const { fetch: read = (value) => fetch(value), ...upload } = options;
+	return AsyncResult.from(async () => {
+		let body;
+		let type;
+		try {
+			const response = await read(uri);
+			if (!response.ok) return err(unreadable(uri, response.status));
+			type = response.headers.get("content-type") ?? void 0;
+			body = await response.arrayBuffer();
+		} catch (cause) {
+			return err(toDbError(cause));
+		}
+		const contentType = upload.contentType ?? contentTypeOf(uri) ?? type;
+		return bucket.upload(target, body, {
+			...upload,
+			...contentType ? { contentType } : {}
+		});
+	});
+}
+function unreadable(uri, status) {
+	return dbError("invalid_input", `better-supabase: could not read ${uri} (status ${String(status)})`);
+}
+//#endregion
+export { autoRefreshOnForeground, contentTypeOf, bindClient as createNativeClient, handleAuthDeepLink, keyValue, largeSecureStorage, linkParams, persistQueryCache, secureStorage, signInWithOAuthBrowser, syncQueryWithApp, uploadFromUri };

package/dist/client-CI0Z2zWX.js

@@ -0,0 +1,277 @@
+import { n as dbError } from "./errors-B11Duf73.js";
+import { r as invalidateTables } from "./user-change-XzvgafU4.js";
+import { n as sessionUserId, r as specKey, t as claimedTenant } from "./keys-4MnkWTTh.js";
+import { n as liveQuery, t as liveCount } from "./live-CTAZQkwl.js";
+//#region src/bindings/client.ts
+/** The caller of the client's auth store. */
+function callerOf(auth) {
+	return {
+		status: auth.status,
+		userId: auth.user?.id ?? null
+	};
+}
+/**
+* The caller of a plain supabase-js client, for subscriptions made without
+* the provider. `loading` until auth-js reports the first state.
+*/
+function plainCaller(supabase) {
+	let caller = {
+		status: "loading",
+		userId: null
+	};
+	return {
+		current: () => caller,
+		subscribe: (listener) => {
+			const { data } = supabase.auth.onAuthStateChange((_event, session) => {
+				caller = {
+					status: session ? "signed-in" : "signed-out",
+					userId: session ? sessionUserId(session) : null
+				};
+				listener();
+			});
+			return () => {
+				data.subscription.unsubscribe();
+			};
+		}
+	};
+}
+/** Throws when `invalidate` has no query client to refetch with. */
+function assertInvalidateClient(hook, options, queryClient) {
+	if (options?.invalidate && !queryClient) throw new Error(`better-supabase: ${hook}({ invalidate }) needs a queryClient on the provider or in the options`);
+}
+/**
+* Subscribes to a topic by its rendered name. Returns the function that
+* leaves, or `undefined` when the name does not match the topic.
+*/
+function startBroadcast(run) {
+	const matched = run.topic.match(run.name);
+	if (!matched) return void 0;
+	const { queryClient } = run;
+	const forward = (payload, message) => {
+		const current = run.latest();
+		const table = current.handlers;
+		(table?.[message.event] ?? table?.["*"])?.(payload, message);
+		const invalidate = current.options?.invalidate;
+		if (!invalidate || !queryClient) return;
+		if (typeof invalidate !== "function") {
+			invalidateTables(queryClient, invalidate);
+			return;
+		}
+		for (const queryKey of invalidate(message)) queryClient.invalidateQueries({ queryKey });
+	};
+	const self = run.latest().options?.self;
+	const subscription = run.topic.subscribe(run.supabase, matched, { "*": forward }, {
+		...self === void 0 ? {} : { self },
+		onStatus: run.onStatus,
+		onInvalid: (message, issues) => run.latest().options?.onInvalid?.(message, issues)
+	});
+	return () => {
+		subscription.unsubscribe();
+		run.onStatus("closed");
+	};
+}
+/** The key a live subscription restarts on: spec, tenant and caller. */
+function liveKey(client, spec, auth, options) {
+	if (!spec || auth.status === "loading") return null;
+	const tenant = options.tenant ?? claimedTenant(auth, client.betterSupabase.meta);
+	return JSON.stringify([
+		specKey(spec),
+		tenant ?? null,
+		auth.user?.id ?? null,
+		options.debounceMs ?? null
+	]);
+}
+/** Invalidates the cached queries that read a table whenever one changes. */
+function startLiveQuery(run) {
+	const { client, queryClient, options } = run;
+	const tenant = options.tenant ?? claimedTenant(run.auth, client.betterSupabase.meta);
+	const userId = run.auth.user?.id ?? null;
+	const live = liveQuery(client.betterSupabase, client.supabase, run.spec, {
+		onChange: (tables) => void invalidateTables(queryClient, tables),
+		onStatus: run.onStatus,
+		...tenant === void 0 ? {} : { tenant },
+		...userId === null ? {} : { user: userId },
+		...options.debounceMs === void 0 ? {} : { debounceMs: options.debounceMs }
+	});
+	if (run.resumed) live.ready.then(() => void invalidateTables(queryClient, live.tables), () => void 0);
+	return () => {
+		live.unsubscribe();
+	};
+}
+/** Splits a count source into its spec and the seed's count and time. */
+function countSource(source, options) {
+	const seed = source && "spec" in source ? source : void 0;
+	return {
+		spec: (seed ? seed.spec : source) ?? null,
+		initial: seed?.count ?? options.initial,
+		seedAt: seed?.at,
+		seeded: seed !== void 0 && seed.count !== null
+	};
+}
+const NO_COUNT = {
+	key: null,
+	count: void 0,
+	at: 0,
+	error: void 0
+};
+/** Refetches the count after each debounced change to a table it reads. */
+function startLiveCount(run) {
+	const { client, key, options } = run;
+	const tenant = options.tenant ?? claimedTenant(run.auth, client.betterSupabase.meta);
+	const userId = run.auth.user?.id ?? null;
+	const live = liveCount(client.betterSupabase, client.supabase, client.db, run.spec, {
+		immediate: run.immediate,
+		...run.since === void 0 ? {} : { since: run.since },
+		onCount: (count) => {
+			const at = Date.now();
+			run.onState(() => ({
+				key,
+				count,
+				at,
+				error: void 0
+			}));
+		},
+		onError: (error) => {
+			run.onState((last) => ({
+				key,
+				count: last.key === key ? last.count : void 0,
+				at: last.key === key ? last.at : 0,
+				error
+			}));
+		},
+		onStatus: run.onStatus,
+		...tenant === void 0 ? {} : { tenant },
+		...userId === null ? {} : { user: userId },
+		...options.debounceMs === void 0 ? {} : { debounceMs: options.debounceMs }
+	});
+	return () => {
+		live.unsubscribe();
+	};
+}
+/** The count to show: the client's, unless a newer server seed arrived. */
+function shownCount(state, key, source) {
+	const fresh = state.key === key;
+	const seedNewer = source.seedAt !== void 0 && source.seeded && source.seedAt > state.at;
+	return {
+		count: fresh && state.count !== void 0 && !seedNewer ? state.count : source.initial,
+		error: fresh ? state.error : void 0
+	};
+}
+const NO_HANDLERS = {};
+/** Joins a presence topic by its rendered name, or `undefined` when it does not match. */
+function joinPresence(supabase, topic, name, handlers) {
+	const matched = topic.match(name);
+	if (!matched) return void 0;
+	const joined = topic.subscribe(supabase, matched, NO_HANDLERS, handlers);
+	let tracked;
+	return {
+		track: async (state) => {
+			const result = await joined.track(state);
+			return result.ok ? void 0 : result.error;
+		},
+		untrack: async () => {
+			const result = await joined.untrack();
+			return result.ok ? void 0 : result.error;
+		},
+		sync(state) {
+			const key = state === void 0 ? void 0 : JSON.stringify(state);
+			if (key === void 0 || key === tracked) return;
+			tracked = key;
+			if (state === null || state === void 0) joined.untrack();
+			else joined.track(state);
+		},
+		leave() {
+			joined.unsubscribe();
+		}
+	};
+}
+/** The error `track` and `untrack` return before the join. */
+const notJoined = () => Promise.resolve(dbError("invalid_request", "better-supabase: the presence topic is not joined"));
+/**
+* Tracks the runs of an action outside React: the inputs in flight, the
+* last data and the last error. `latest` is read on each run, so the action
+* and the callbacks can change between runs.
+*/
+function createActionRunner(latest) {
+	const listeners = /* @__PURE__ */ new Set();
+	let inFlight = [];
+	let data;
+	let error;
+	let state = snapshot();
+	function snapshot() {
+		const pendingInputs = inFlight.map((item) => item.input);
+		return {
+			pending: inFlight.length > 0,
+			pendingInputs,
+			pendingInput: pendingInputs.at(-1),
+			data,
+			error
+		};
+	}
+	const emit = () => {
+		state = snapshot();
+		for (const listener of listeners) listener();
+	};
+	return {
+		current: () => state,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		run: async (input) => {
+			const entry = { input };
+			inFlight = [...inFlight, entry];
+			error = void 0;
+			emit();
+			const done = () => {
+				inFlight = inFlight.filter((item) => item !== entry);
+			};
+			const { action, options } = latest();
+			let result;
+			try {
+				result = await action(input);
+			} catch (cause) {
+				done();
+				emit();
+				throw cause;
+			}
+			done();
+			if (result.ok) data = result.data;
+			else error = result.error;
+			emit();
+			if (result.ok) options.onSuccess?.(result.data, input);
+			else options.onError?.(result.error, input);
+			return result;
+		},
+		reset: () => {
+			data = void 0;
+			error = void 0;
+			emit();
+		}
+	};
+}
+/**
+* One run per key: `update` restarts `start` when the key changes and stops
+* the run when the key is `null`.
+*/
+function keyed() {
+	let current;
+	return {
+		update: (key, start) => {
+			if (current?.key === key) return;
+			current?.stop?.();
+			current = key === null ? void 0 : {
+				key,
+				stop: start()
+			};
+		},
+		stop: () => {
+			current?.stop?.();
+			current = void 0;
+		}
+	};
+}
+//#endregion
+export { createActionRunner as a, liveKey as c, shownCount as d, startBroadcast as f, countSource as i, notJoined as l, startLiveQuery as m, assertInvalidateClient as n, joinPresence as o, startLiveCount as p, callerOf as r, keyed as s, NO_COUNT as t, plainCaller as u };

package/dist/cloud-event-BnmD5fb9.js

@@ -0,0 +1,46 @@
+//#region src/events/cloud-event.ts
+/**
+* A block event as a CloudEvent: `dev.better-supabase.support.started` with
+* the event data and the actor (`actorId`) as `data` and the tenant as
+* `partitionkey`.
+*/
+function blockCloudEvent(event, options) {
+	return {
+		specversion: "1.0",
+		id: options.id?.() ?? crypto.randomUUID(),
+		source: options.source,
+		type: `${options.typePrefix ?? "dev.better-supabase"}.${event.type}`,
+		...event.subject ? { subject: event.subject } : {},
+		time: (options.now?.() ?? event.time).toString(),
+		datacontenttype: "application/json",
+		data: event.actorId ? {
+			...event.data,
+			actorId: event.actorId
+		} : event.data,
+		...event.tenant ? { partitionkey: event.tenant } : {}
+	};
+}
+/**
+* Sends a CloudEvent for every block event (`support.*`, `organization.*`, ...) to
+* `sink`. Returns a function that stops forwarding. Like
+* `forwardMutations`, sends are tracked on `betterSupabase.events`.
+*/
+function forwardBlockEvents(betterSupabase, sink, options) {
+	const types = options.types;
+	return betterSupabase.events.on("block", (event) => {
+		if (types && !types.some((pattern) => pattern.endsWith(".*") ? event.type.startsWith(pattern.slice(0, -1)) : pattern === event.type)) return;
+		const events = [blockCloudEvent(event, options)];
+		const report = (error) => {
+			(options.onError ?? ((cause) => {
+				betterSupabase.events.logger.error("event sink failed", { cause });
+			}))(error, events);
+		};
+		try {
+			betterSupabase.events.track(Promise.resolve(sink.send(events)).catch(report));
+		} catch (error) {
+			report(error);
+		}
+	});
+}
+//#endregion
+export { forwardBlockEvents as n, blockCloudEvent as t };