better-supabase 0.5.1 → 0.6.0

package/dist/list-query-gl808ac1.js

@@ -0,0 +1,459 @@
+//#region src/list/list-query.ts
+/** Facet value meaning "not set": filters with `is null`. */
+const UNSET = "__unset__";
+const RESERVED = /* @__PURE__ */ new Set([
+	"q",
+	"sort",
+	"page",
+	"after",
+	"size"
+]);
+function first(value) {
+	return typeof value === "string" ? value : value?.[0];
+}
+function all(value) {
+	return (typeof value === "string" ? [value] : [...value ?? []]).flatMap((entry) => entry.split(",")).map((entry) => entry.trim()).filter(Boolean);
+}
+const isParamValue = (value) => value === void 0 || typeof value === "string" || Array.isArray(value) && value.every((entry) => typeof entry === "string");
+function isSearchParams(value) {
+	return value instanceof URLSearchParams || !("facets" in value && typeof value.facets === "object") && Object.values(value).every(isParamValue);
+}
+function readRecord(input) {
+	if (!(input instanceof URLSearchParams)) return input;
+	const out = {};
+	for (const [key, value] of input) (out[key] ??= []).push(value);
+	return out;
+}
+function toInt(raw) {
+	if (typeof raw === "number") return raw;
+	if (typeof raw !== "string" || !/^\d+$/.test(raw)) return NaN;
+	return Number(raw);
+}
+/**
+* A reusable list endpoint for one table: search, facets, sorts and
+* pagination, validated from URL params or typed input, with URL parsers,
+* OpenAPI parameters and a JSON Schema derived from the same definition.
+*
+* ```ts
+* export const customerList = defineListQuery(betterSupabase, 'customers', {
+*   search: ['name', 'kvk'],
+*   facets: { status: 'status' },
+*   sorts: { name: { name: 'asc' }, newest: [{ createdAt: 'desc' }, { id: 'asc' }] },
+*   defaultSort: 'newest',
+* });
+* ```
+*/
+function defineListQuery(betterSupabase, table, config) {
+	const meta = betterSupabase.meta.tables[table];
+	if (!meta) throw new TypeError(`defineListQuery: unknown table "${table}"`);
+	const pageSize = config.pageSize ?? 50;
+	const maxPageSize = config.maxPageSize ?? 200;
+	const maxSearch = config.maxSearchLength ?? 200;
+	const facetLimit = config.facetLimit ?? 100;
+	const cursor = config.pagination === "cursor";
+	const sortKeys = Object.keys(config.sorts);
+	const facetEntries = Object.entries(config.facets ?? {});
+	for (const [key, column] of facetEntries) {
+		if (RESERVED.has(key)) throw new TypeError(`defineListQuery: facet key "${key}" is reserved`);
+		if (!meta.columns[column]) throw new TypeError(`defineListQuery: unknown column "${table}.${column}"`);
+	}
+	if (!sortKeys.includes(config.defaultSort)) throw new TypeError(`defineListQuery: defaultSort "${config.defaultSort}" is not in sorts`);
+	const facets = facetEntries.map(([key, column]) => {
+		const columnMeta = meta.columns[column];
+		return {
+			key,
+			column,
+			nullable: columnMeta.nullable,
+			...columnMeta.enum ? { values: columnMeta.enum } : {}
+		};
+	});
+	const defaults = {
+		sort: config.defaultSort,
+		page: 1,
+		size: pageSize,
+		facets: {}
+	};
+	function normalize(raw) {
+		const issues = [];
+		let q;
+		if (raw.q !== void 0 && raw.q !== null) {
+			if (typeof raw.q !== "string") issues.push({
+				message: "Must be text",
+				path: ["q"]
+			});
+			else if (raw.q.trim().length > maxSearch) issues.push({
+				message: `At most ${String(maxSearch)} characters`,
+				path: ["q"]
+			});
+			else if (raw.q.trim()) q = raw.q.trim();
+		}
+		let sort = config.defaultSort;
+		if (raw.sort !== void 0 && raw.sort !== "") {
+			if (typeof raw.sort === "string" && sortKeys.includes(raw.sort)) sort = raw.sort;
+			else issues.push({
+				message: `Must be one of: ${sortKeys.join(", ")}`,
+				path: ["sort"]
+			});
+		}
+		const page = raw.page === void 0 || raw.page === "" ? 1 : toInt(raw.page);
+		if (page === void 0 || !Number.isInteger(page) || page < 1) issues.push({
+			message: "Must be a whole number of at least 1",
+			path: ["page"]
+		});
+		else if (cursor && page !== 1) issues.push({
+			message: "This list pages with `after`, not `page`",
+			path: ["page"]
+		});
+		let after;
+		if (raw.after !== void 0 && raw.after !== "") {
+			if (cursor && typeof raw.after === "string") after = raw.after;
+			else issues.push({
+				message: cursor ? "Must be text" : "This list pages with `page`, not `after`",
+				path: ["after"]
+			});
+		}
+		const size = raw.size === void 0 || raw.size === "" ? pageSize : toInt(raw.size);
+		if (size === void 0 || !Number.isInteger(size) || size < 1 || size > maxPageSize) issues.push({
+			message: `Must be a whole number from 1 to ${String(maxPageSize)}`,
+			path: ["size"]
+		});
+		const facetValues = {};
+		for (const facet of facets) {
+			const values = raw.facets[facet.key];
+			if (!values || values.length === 0) continue;
+			for (const value of values) if (!(value === "__unset__" ? facet.nullable : !facet.values || facet.values.includes(value))) issues.push({
+				message: value === "__unset__" ? "This filter cannot be empty" : `Must be one of: ${(facet.values ?? []).join(", ")}`,
+				path: ["facets", facet.key]
+			});
+			facetValues[facet.key] = [...new Set(values)];
+		}
+		if (issues.length > 0) return {
+			ok: false,
+			issues
+		};
+		return {
+			ok: true,
+			value: {
+				...q ? { q } : {},
+				sort,
+				page: page ?? 1,
+				...after ? { after } : {},
+				size: size ?? pageSize,
+				facets: facetValues
+			}
+		};
+	}
+	function parse(input) {
+		if (input === void 0 || input === null) return {
+			ok: true,
+			value: defaults
+		};
+		if (typeof input !== "object") return {
+			ok: false,
+			issues: [{ message: "Expected an object or URL parameters" }]
+		};
+		if (isSearchParams(input)) {
+			const record = readRecord(input);
+			const facetValues = {};
+			for (const facet of facets) facetValues[facet.key] = all(record[facet.key]);
+			return normalize({
+				q: first(record["q"]),
+				sort: first(record["sort"]),
+				page: first(record["page"]),
+				after: first(record["after"]),
+				size: first(record["size"]),
+				facets: facetValues
+			});
+		}
+		const typed = input;
+		const rawFacets = typed.facets ?? {};
+		for (const [key, value] of Object.entries(rawFacets)) if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) return {
+			ok: false,
+			issues: [{
+				message: "Must be a list of values",
+				path: ["facets", key]
+			}]
+		};
+		return normalize({
+			q: typed.q,
+			sort: typed.sort,
+			page: typed.page,
+			after: typed.after,
+			size: typed.size,
+			facets: rawFacets
+		});
+	}
+	function searchWhere(query) {
+		if (!query.q || !config.search) return void 0;
+		if (Array.isArray(config.search)) {
+			const columns = config.search;
+			if (columns.length === 0) return void 0;
+			return { OR: columns.map((column) => ({ [column]: { contains: query.q } })) };
+		}
+		const fts = config.search;
+		return { [fts.fts]: { search: fts.config ? {
+			query: query.q,
+			config: fts.config
+		} : query.q } };
+	}
+	function facetWhere(facet, values) {
+		if (!values || values.length === 0) return void 0;
+		const unset = values.includes(UNSET);
+		const set = values.filter((value) => value !== UNSET);
+		if (unset && set.length === 0) return { [facet.column]: null };
+		if (!unset) return { [facet.column]: { in: set } };
+		return { OR: [{ [facet.column]: { in: set } }, { [facet.column]: null }] };
+	}
+	function and(parts) {
+		const present = parts.filter((part) => part !== void 0);
+		if (present.length === 0) return void 0;
+		return present.length === 1 ? present[0] : { AND: present };
+	}
+	function where(query) {
+		return and([searchWhere(query), ...facets.map((facet) => facetWhere(facet, query.facets[facet.key]))]);
+	}
+	function args(query) {
+		const filter = where(query);
+		const paging = cursor ? { after: query.after ?? null } : {
+			page: query.page,
+			count: config.count ?? "planned"
+		};
+		return {
+			...filter ? { where: filter } : {},
+			orderBy: config.sorts[query.sort],
+			size: query.size,
+			...paging
+		};
+	}
+	/** Rows per value of one facet, from its grouped aggregate. */
+	function countsOf(facet, groups) {
+		const counts = {};
+		for (const value of facet.values ?? []) counts[value] = 0;
+		for (const group of groups) {
+			const raw = group[facet.column];
+			const key = raw === null || raw === void 0 ? UNSET : String(raw);
+			counts[key] = (counts[key] ?? 0) + Number(group["_count"] ?? 0);
+		}
+		return counts;
+	}
+	const listParser = {
+		parse: (value) => {
+			const values = all(value);
+			return values.length > 0 ? values : null;
+		},
+		serialize: (values) => values.join(",")
+	};
+	const intParser = {
+		parse: (value) => /^\d+$/.test(value) ? Number(value) : null,
+		serialize: String
+	};
+	const parsers = {
+		q: {
+			parse: (value) => value.trim() || null,
+			serialize: (value) => value
+		},
+		sort: {
+			parse: (value) => sortKeys.includes(value) ? value : null,
+			serialize: (value) => value
+		},
+		page: intParser,
+		after: {
+			parse: (value) => value || null,
+			serialize: (value) => value
+		},
+		size: intParser,
+		...Object.fromEntries(facets.map((facet) => [facet.key, listParser]))
+	};
+	const facetSchema = (facet) => ({
+		type: "array",
+		items: {
+			type: "string",
+			...facet.values ? { enum: [...facet.values, ...facet.nullable ? [UNSET] : []] } : {}
+		},
+		uniqueItems: true
+	});
+	const searchDescription = config.search ? Array.isArray(config.search) ? `Case-insensitive search in ${config.search.join(", ")}.` : "Full-text search (web search syntax)." : void 0;
+	const openapi = [
+		...searchDescription ? [{
+			name: "q",
+			in: "query",
+			required: false,
+			description: searchDescription,
+			schema: {
+				type: "string",
+				maxLength: maxSearch
+			}
+		}] : [],
+		{
+			name: "sort",
+			in: "query",
+			required: false,
+			description: `Ordering. Default \`${config.defaultSort}\`.`,
+			schema: {
+				type: "string",
+				enum: sortKeys,
+				default: config.defaultSort
+			}
+		},
+		cursor ? {
+			name: "after",
+			in: "query",
+			required: false,
+			description: "`nextCursor` of the previous page. Leave it out for the first page.",
+			schema: { type: "string" }
+		} : {
+			name: "page",
+			in: "query",
+			required: false,
+			description: "1-based page number.",
+			schema: {
+				type: "integer",
+				minimum: 1,
+				default: 1
+			}
+		},
+		{
+			name: "size",
+			in: "query",
+			required: false,
+			description: "Page size.",
+			schema: {
+				type: "integer",
+				minimum: 1,
+				maximum: maxPageSize,
+				default: pageSize
+			}
+		},
+		...facets.map((facet) => ({
+			name: facet.key,
+			in: "query",
+			required: false,
+			description: `Filter on ${facet.column}. Comma-separated; any value matches.${facet.nullable ? ` \`${UNSET}\` matches empty.` : ""}`,
+			schema: facetSchema(facet),
+			style: "form",
+			explode: false
+		}))
+	];
+	const jsonSchema = {
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			...searchDescription ? { q: {
+				type: "string",
+				maxLength: maxSearch,
+				description: searchDescription
+			} } : {},
+			sort: {
+				type: "string",
+				enum: sortKeys,
+				default: config.defaultSort
+			},
+			...cursor ? { after: { type: "string" } } : { page: {
+				type: "integer",
+				minimum: 1,
+				default: 1
+			} },
+			size: {
+				type: "integer",
+				minimum: 1,
+				maximum: maxPageSize,
+				default: pageSize
+			},
+			...facets.length > 0 ? { facets: {
+				type: "object",
+				additionalProperties: false,
+				properties: Object.fromEntries(facets.map((facet) => [facet.key, facetSchema(facet)]))
+			} } : {}
+		}
+	};
+	return {
+		table,
+		pagination: config.pagination ?? "offset",
+		defaults,
+		facets,
+		parse,
+		schema: { "~standard": {
+			version: 1,
+			vendor: "better-supabase",
+			validate(value) {
+				const result = parse(value);
+				return result.ok ? { value: result.value } : { issues: result.issues };
+			}
+		} },
+		toSearchParams(query) {
+			const params = new URLSearchParams();
+			if (query.q) params.set("q", query.q);
+			if (query.sort && query.sort !== config.defaultSort) params.set("sort", query.sort);
+			if (query.page && query.page !== 1) params.set("page", String(query.page));
+			if (query.after) params.set("after", query.after);
+			if (query.size !== void 0 && query.size > 0 && query.size !== pageSize) params.set("size", String(query.size));
+			for (const facet of facets) {
+				const values = query.facets?.[facet.key];
+				if (values && values.length > 0) params.set(facet.key, values.join(","));
+			}
+			return params;
+		},
+		parsers,
+		nuqs: (createParser) => Object.fromEntries(Object.entries(parsers).map(([key, spec]) => [key, createParser(spec)])),
+		args,
+		run(db, query, extra) {
+			const base = args(query);
+			const { where: extraWhere, count, select: _select, include: _include, ...options } = extra ?? {};
+			const combined = and([extraWhere, base["where"]]);
+			const repository = db[table];
+			const page = repository.paginate({
+				...extra,
+				...base,
+				...cursor ? {} : { count: count ?? base["count"] },
+				...combined ? { where: combined } : {}
+			});
+			if (!config.facetCounts) return page;
+			if (facets.length === 0) return page.map((data) => ({
+				...data,
+				facetCounts: {},
+				facetCountsTruncated: []
+			}));
+			const search = searchWhere(query);
+			const counted = facets.map((facet) => {
+				const filter = and([
+					extraWhere,
+					search,
+					...facets.map((other) => other === facet ? void 0 : facetWhere(other, query.facets[other.key]))
+				]);
+				return repository.aggregate({
+					...options,
+					...filter ? { where: filter } : {},
+					groupBy: [facet.column],
+					_count: true,
+					orderBy: [{ _count: "desc" }, { [facet.column]: "asc" }],
+					limit: facetLimit + 1
+				});
+			});
+			return page.andThen(async (data) => {
+				const results = await Promise.all(counted);
+				const facetCounts = {};
+				const truncated = [];
+				for (const [index, facet] of facets.entries()) {
+					const result = results[index];
+					if (!result.ok) return result;
+					const rows = result.data;
+					if (rows.length > facetLimit) truncated.push(facet.key);
+					facetCounts[facet.key] = countsOf(facet, rows.slice(0, facetLimit));
+				}
+				return {
+					ok: true,
+					data: {
+						...data,
+						facetCounts,
+						facetCountsTruncated: truncated
+					},
+					error: null
+				};
+			});
+		},
+		openapi,
+		jsonSchema
+	};
+}
+//#endregion
+export { defineListQuery as n, UNSET as t };

package/dist/{live-CdJBOc4f.js → live-CTAZQkwl.js}

@@ -1,16 +1,43 @@
 import { REALTIME_SUBSCRIBE_STATES } from "@supabase/supabase-js";
+//#region src/realtime/auth.ts
+/**
+* Hands the client's access token to Realtime before a private join,
+* unless the app set one itself with `realtime.setAuth(token)`. A bare
+* `setAuth()` replaces such a token with the session's, so a client that
+* joins with a token minted for Realtime (a service or agent token) keeps it.
+* realtime-js versions without the manual-token check always refresh.
+*/
+async function refreshRealtimeAuth(client) {
+	if (manualToken(client.realtime)) return;
+	await client.realtime.setAuth();
+}
+/** Whether realtime-js says the token came from `setAuth(token)`. */
+function manualToken(realtime) {
+	if (!("_isManualToken" in realtime)) return false;
+	const check = realtime._isManualToken;
+	return typeof check === "function" && check.call(realtime) === true;
+}
+//#endregion
 //#region src/realtime/live.ts
-/** Topic a `realtime-tables` trigger broadcasts on: `bs:t:<schema>.<table>[:<tenant>]`. */
-function liveTopic(meta, table, tenant) {
+/**
+* Topic a `realtime-tables` trigger broadcasts on:
+* `bs:t:<schema>.<table>[:<tenant>]`, or `bs:t:<schema>.<table>:u:<user>`
+* for a `realtime.users` table.
+*/
+function liveTopic(meta, table, tenant, user) {
 	const found = meta.tables[table];
 	if (!found) throw new TypeError(`better-supabase: unknown table "${table}"`);
 	const base = `bs:t:${found.schema}.${found.name}`;
+	if (meta.realtime?.[table]?.user) {
+		if (user === void 0) throw new TypeError(`better-supabase: "${table}" broadcasts per user; pass \`user\` to watch it`);
+		return `${base}:u:${user}`;
+	}
 	if (!meta.realtime?.[table]?.tenant) return base;
 	if (tenant === void 0) throw new TypeError(`better-supabase: "${table}" broadcasts per tenant; pass \`tenant\` to watch it`);
 	return `${base}:${tenant}`;
 }
 const channels = /* @__PURE__ */ new WeakMap();
-function join(client, topic, listener) {
+function join(client, topic, listener, onStatus) {
 	let byTopic = channels.get(client);
 	if (!byTopic) {
 		byTopic = /* @__PURE__ */ new Map();
@@ -20,17 +47,26 @@ function join(client, topic, listener) {
 	if (!shared) {
 		const channel = client.channel(topic, { config: { private: true } });
 		const listeners = /* @__PURE__ */ new Set();
+		const statuses = /* @__PURE__ */ new Set();
 		channel.on("broadcast", { event: "change" }, () => {
 			for (const notify of listeners) notify();
 		});
 		let joined = false;
+		const evict = () => {
+			if (byTopic.get(topic) !== entry) return;
+			byTopic.delete(topic);
+			client.removeChannel(channel);
+		};
 		const ready = (async () => {
-			await client.realtime.setAuth();
+			await refreshRealtimeAuth(client);
 			await new Promise((resolve, reject) => {
 				channel.subscribe((status, error) => {
 					switch (status) {
 						case REALTIME_SUBSCRIBE_STATES.SUBSCRIBED:
-							if (joined) for (const notify of listeners) notify();
+							if (joined) {
+								for (const notify of listeners) notify();
+								for (const notify of statuses) notify("subscribed");
+							}
 							joined = true;
 							resolve();
 							return;
@@ -38,24 +74,31 @@ function join(client, topic, listener) {
 							resolve();
 							return;
 						case REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR:
-						case REALTIME_SUBSCRIBE_STATES.TIMED_OUT:
-							reject(error ?? /* @__PURE__ */ new Error(`Realtime ${status.toLowerCase()} on ${topic}`));
+						case REALTIME_SUBSCRIBE_STATES.TIMED_OUT: {
+							const failure = error ?? /* @__PURE__ */ new Error(`Realtime ${status.toLowerCase()} on ${topic}`);
+							if (joined) for (const notify of statuses) notify("error", failure);
+							reject(failure);
+							if (!joined) evict();
 							return;
+						}
 						default: reject(/* @__PURE__ */ new Error(`Unknown realtime status ${String(status)}`));
 					}
 				});
 			});
 		})();
 		ready.catch(() => void 0);
-		shared = {
+		const entry = {
 			channel,
 			listeners,
+			statuses,
 			ready
 		};
-		byTopic.set(topic, shared);
+		shared = entry;
+		byTopic.set(topic, entry);
 	}
 	const current = shared;
 	current.listeners.add(listener);
+	if (onStatus) current.statuses.add(onStatus);
 	let left = false;
 	return {
 		ready: current.ready,
@@ -63,6 +106,7 @@ function join(client, topic, listener) {
 			if (left) return;
 			left = true;
 			current.listeners.delete(listener);
+			if (onStatus) current.statuses.delete(onStatus);
 			if (current.listeners.size > 0) return;
 			await new Promise((resolve) => {
 				setTimeout(resolve, 0);
@@ -98,24 +142,60 @@ function liveQuery(betterSupabase, client, spec, options) {
 		changed.clear();
 		options.onChange(batch);
 	};
-	const memberships = tables.map((table) => join(client, liveTopic(betterSupabase.meta, table, options.tenant), () => {
+	const onTableChange = (table) => () => {
 		changed.add(table);
 		if (timer !== void 0) clearTimeout(timer);
 		timer = setTimeout(flush, debounceMs);
+	};
+	const failed = /* @__PURE__ */ new Set();
+	const onChannelStatus = (topic) => (status, error) => {
+		if (closed) return;
+		if (status === "error") failed.add(topic);
+		else failed.delete(topic);
+		if (status === "error") options.onStatus?.("error", error);
+		else if (failed.size === 0) options.onStatus?.("subscribed");
+	};
+	const topics = tables.map((table) => ({
+		table,
+		topic: liveTopic(betterSupabase.meta, table, options.tenant, options.user)
 	}));
-	options.onStatus?.(tables.length === 0 ? "closed" : "joining");
-	const ready = Promise.all(memberships.map((member) => member.ready)).then(() => {
+	const joinAll = () => topics.map(({ table, topic }) => join(client, topic, onTableChange(table), onChannelStatus(topic)));
+	let memberships = joinAll();
+	let retryTimer;
+	let delay = 1e3;
+	const settle = (attempt) => Promise.all(attempt.map((member) => member.ready)).then(() => {
 		if (!closed && tables.length > 0) options.onStatus?.("subscribed");
 	}, (cause) => {
 		const error = cause instanceof Error ? cause : new Error(String(cause));
-		options.onStatus?.("error", error);
+		if (!closed) {
+			options.onStatus?.("error", error);
+			if (options.retry !== false) scheduleRetry(attempt);
+		}
 		throw error;
 	});
+	const scheduleRetry = (attempt) => {
+		retryTimer = setTimeout(() => {
+			retryTimer = void 0;
+			if (closed || attempt !== memberships) return;
+			Promise.all(attempt.map((member) => member.leave()));
+			memberships = joinAll();
+			options.onStatus?.("joining");
+			settle(memberships).then(() => {
+				if (closed) return;
+				for (const table of tables) changed.add(table);
+				flush();
+			}, () => void 0);
+		}, delay);
+		delay = Math.min(delay * 2, 3e4);
+	};
+	options.onStatus?.(tables.length === 0 ? "closed" : "joining");
+	const ready = settle(memberships);
 	ready.catch(() => void 0);
 	const unsubscribe = async () => {
 		if (closed) return;
 		closed = true;
 		if (timer !== void 0) clearTimeout(timer);
+		if (retryTimer !== void 0) clearTimeout(retryTimer);
 		await Promise.all(memberships.map((member) => member.leave()));
 		options.onStatus?.("closed");
 	};
@@ -153,10 +233,15 @@ function liveCount(betterSupabase, client, db, spec, options) {
 	const live = liveQuery(betterSupabase, client, spec, {
 		onChange: refetch,
 		...options.tenant === void 0 ? {} : { tenant: options.tenant },
+		...options.user === void 0 ? {} : { user: options.user },
 		...options.debounceMs === void 0 ? {} : { debounceMs: options.debounceMs },
 		...options.onStatus ? { onStatus: options.onStatus } : {}
 	});
 	if (options.immediate ?? true) refetch();
+	const since = options.since;
+	if (since !== void 0) live.ready.then(() => {
+		if (!closed && Date.now() - since > 1e3) refetch();
+	}, () => void 0);
 	const unsubscribe = async () => {
 		closed = true;
 		await live.unsubscribe();
@@ -169,4 +254,4 @@ function liveCount(betterSupabase, client, db, spec, options) {
 	};
 }
 //#endregion
-export { liveQuery as n, liveTopic as r, liveCount as t };
+export { refreshRealtimeAuth as i, liveQuery as n, liveTopic as r, liveCount as t };

package/dist/logger-DWVYUmwi.d.ts

@@ -0,0 +1,18 @@
+//#region src/core/logger.d.ts
+type LogFields = Readonly<Record<string, unknown>>;
+/**
+ * Where better-supabase reports problems it swallows on purpose: event
+ * handlers, `afterMutation` hooks, sinks and cache adapters that throw.
+ * Structured loggers (pino, consola, OpenTelemetry logs) fit directly.
+ */
+interface Logger {
+  debug(message: string, fields?: LogFields): void;
+  info(message: string, fields?: LogFields): void;
+  warn(message: string, fields?: LogFields): void;
+  error(message: string, fields?: LogFields): void;
+}
+/** The default: `console`, with a `better-supabase:` prefix. */
+declare const consoleLogger: Logger;
+declare const silentLogger: Logger;
+//#endregion
+export { silentLogger as i, Logger as n, consoleLogger as r, LogFields as t };