better-supabase 0.5.1 → 0.6.0

package/dist/bind-l4kAvYSv.js

@@ -0,0 +1,97 @@
+import { n as decodeJwtPayload } from "./base64-D2gsioCY.js";
+import { i as userContext } from "./impersonation-DcqaTBHx.js";
+import { n as identityKey } from "./user-change-XzvgafU4.js";
+import { n as createQueries } from "./query-BQ-NaZon.js";
+//#region src/client/bind.ts
+const LOADING = {
+	status: "loading",
+	user: null,
+	claims: null
+};
+const SIGNED_OUT = {
+	status: "signed-out",
+	user: null,
+	claims: null
+};
+/**
+* `session.user`, or `undefined` when auth-js put its placeholder there: with
+* `tokens-only` cookies and no user in `userStorage`, reading `id` throws.
+*/
+function storedUser(session) {
+	try {
+		return typeof session.user.id === "string" ? session.user : void 0;
+	} catch {
+		return;
+	}
+}
+const text = (value) => typeof value === "string" && value !== "" ? value : void 0;
+function snapshotOf(session) {
+	if (!session) return SIGNED_OUT;
+	const claims = decodeJwtPayload(session.access_token) ?? {};
+	const stored = storedUser(session);
+	const id = text(claims["sub"]) ?? stored?.id;
+	if (id === void 0) return SIGNED_OUT;
+	const email = text(claims["email"]) ?? text(stored?.email);
+	const role = text(claims["role"]) ?? text(stored?.role);
+	return {
+		status: "signed-in",
+		user: {
+			id,
+			...email ? { email } : {},
+			...role ? { role } : {}
+		},
+		claims
+	};
+}
+function contextOf(snapshot) {
+	if (snapshot.status !== "signed-in") return {
+		actor: {
+			id: "anon",
+			kind: "anon",
+			role: "anon"
+		},
+		claims: { role: "anon" }
+	};
+	return userContext(snapshot.user, snapshot.claims);
+}
+/**
+* Repositories that follow `supabase`'s session, TanStack Query options and
+* an auth store, for a supabase-js client you created yourself.
+*/
+function bindClient(betterSupabase, supabase, options = {}) {
+	let snapshot = LOADING;
+	let db;
+	const listeners = /* @__PURE__ */ new Set();
+	const { data } = supabase.auth.onAuthStateChange((_event, session) => {
+		const next = snapshotOf(session);
+		if (next.status === snapshot.status && identityKey(next) === identityKey(snapshot)) return;
+		snapshot = next;
+		db = void 0;
+		for (const listener of listeners) listener();
+	});
+	const client = {
+		betterSupabase,
+		supabase,
+		get db() {
+			db ??= betterSupabase.connect(supabase, contextOf(snapshot));
+			return db;
+		},
+		queries: createQueries(betterSupabase, () => client.db, options.staleTime === void 0 ? {} : { staleTime: options.staleTime }),
+		dispose: () => {
+			data.subscription.unsubscribe();
+			listeners.clear();
+		},
+		auth: {
+			current: () => snapshot,
+			subscribe: (listener) => {
+				listeners.add(listener);
+				return () => {
+					listeners.delete(listener);
+				};
+			}
+		}
+	};
+	return client;
+}
+//#endregion
+export { bindClient as t };

package/dist/block-events-CrT8r7Fe.js

@@ -0,0 +1,76 @@
+import { t as cloneValue } from "./clone-BfgmLU90.js";
+import { s as nowInstant } from "./temporal-BJGitm-h.js";
+//#region src/core/block-events.ts
+/**
+* Event types that changed name in 0.6, old to new, for sinks and consumers
+* that still receive the old ones (`BLOCK_EVENT_RENAMES[type] ?? type`).
+* `better-supabase codemod 0.6` rewrites the string literals.
+*/
+const BLOCK_EVENT_RENAMES = {
+	"org.created": "organization.created",
+	"org.updated": "organization.updated",
+	"org.deleted": "organization.deleted",
+	"org.member_added": "organization.member_added",
+	"org.member_removed": "organization.member_removed",
+	"org.member_left": "organization.member_left",
+	"org.role_changed": "organization.role_changed",
+	"org.ownership_transferred": "organization.ownership_transferred",
+	"org.switched": "organization.switched"
+};
+/**
+* Fixed OpenTelemetry attribute names for block work, so dashboards and
+* queries can rely on them.
+*/
+const BLOCK_ATTRIBUTES = {
+	event: "better_supabase.block.event",
+	tenant: "better_supabase.tenant",
+	actor: "better_supabase.actor.id",
+	supportSessionId: "better_supabase.support.session_id",
+	organizationId: "better_supabase.organization.id",
+	invitationId: "better_supabase.invitation.id",
+	notificationType: "better_supabase.notification.type",
+	webhookEndpointId: "better_supabase.webhook.endpoint_id"
+};
+/** The `BLOCK_ATTRIBUTES` an event carries. */
+function blockEventAttributes(event) {
+	const attributes = { [BLOCK_ATTRIBUTES.event]: event.type };
+	if (event.tenant) attributes[BLOCK_ATTRIBUTES.tenant] = event.tenant;
+	if (event.actorId) attributes[BLOCK_ATTRIBUTES.actor] = event.actorId;
+	const data = Object.fromEntries(Object.entries(event.data));
+	const add = (key, value) => {
+		if (typeof value === "string" && value.length > 0) attributes[key] = value;
+	};
+	add(BLOCK_ATTRIBUTES.supportSessionId, data["sessionId"]);
+	add(BLOCK_ATTRIBUTES.organizationId, data["organizationId"]);
+	add(BLOCK_ATTRIBUTES.invitationId, data["invitationId"]);
+	add(BLOCK_ATTRIBUTES.notificationType, data["type"]);
+	add(BLOCK_ATTRIBUTES.webhookEndpointId, data["endpointId"]);
+	return attributes;
+}
+/**
+* Emits a block event on `events` with a copy of `data`. Does nothing without
+* a `block` handler, so blocks call it unconditionally.
+*/
+function emitBlockEvent(events, type, data, meta = {}) {
+	if (!events.has("block")) return;
+	const event = {
+		...meta,
+		type,
+		data: cloneValue(data),
+		time: nowInstant()
+	};
+	events.emit("block", event);
+}
+const matches = (pattern, type) => pattern.endsWith(".*") ? type.startsWith(pattern.slice(0, -1)) : pattern === type;
+/**
+* Listens to the block events that match `pattern` (`'support.started'` or
+* `'support.*'`). Returns a function that stops listening.
+*/
+function onBlockEvent(betterSupabase, pattern, handler) {
+	return betterSupabase.events.on("block", (event) => {
+		if (!matches(pattern, event.type)) return;
+		handler(event);
+	});
+}
+//#endregion
+export { onBlockEvent as a, emitBlockEvent as i, BLOCK_EVENT_RENAMES as n, blockEventAttributes as r, BLOCK_ATTRIBUTES as t };

package/dist/block-fields-GFkxl4dP.js

@@ -0,0 +1,49 @@
+import { n as dbError } from "./errors-B11Duf73.js";
+import { a as ok, r as err } from "./result-DzUbqgdW.js";
+import { t as toIssues } from "./standard-BK0cqJ7y.js";
+//#region src/core/block-fields.ts
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+async function run(schema, value) {
+	return schema["~standard"].validate(value);
+}
+const invalid = (label, issues) => err(dbError("validation", `Invalid ${label}`, { issues }));
+/**
+* The `fields` helper block creators use. Without a schema, reads and
+* writes pass through unchanged.
+*/
+function blockFields(schema, label) {
+	return {
+		async read(row) {
+			if (schema === void 0) return ok(row);
+			const outcome = await run(schema, row);
+			if (outcome.issues) return invalid(label, toIssues(outcome.issues));
+			if (!isObject(outcome.value)) return invalid(label, [{ message: "fields must parse to an object" }]);
+			return ok({
+				...row,
+				...outcome.value
+			});
+		},
+		async write(attrs) {
+			if (schema === void 0) return ok(attrs);
+			const outcome = await run(schema, attrs);
+			if (!outcome.issues) {
+				if (!isObject(outcome.value)) return ok(attrs);
+				const parsed = outcome.value;
+				const picked = Object.fromEntries(Object.keys(attrs).filter((key) => key in parsed).map((key) => [key, parsed[key]]));
+				return ok({
+					...attrs,
+					...picked
+				});
+			}
+			const given = new Set(Object.keys(attrs));
+			const relevant = toIssues(outcome.issues).filter((issue) => {
+				const [first] = issue.path ?? [];
+				return first === void 0 || given.has(String(first));
+			});
+			if (relevant.length === 0) return ok(attrs);
+			return invalid(label, relevant);
+		}
+	};
+}
+//#endregion
+export { blockFields as t };

package/dist/block-fields-SJ6fEf3o.d.ts

@@ -0,0 +1,31 @@
+import { f as Result } from "./result-D7y2fT87.js";
+import { t as StandardSchemaV1 } from "./standard-CYsm7xpT.js";
+//#region src/core/block-fields.d.ts
+/** The fields a `fields` schema adds, or none when the block has no schema. */
+type FieldsOf<S> = S extends StandardSchemaV1<unknown, infer O> ? O extends object ? O : never : Record<never, never>;
+/**
+ * Parses and validates the extra fields an app adds to a block's table,
+ * with any Standard Schema (zod, valibot, arktype) for an object.
+ */
+interface BlockFields<T extends object> {
+  /**
+   * Parses a row the block read: the schema's output replaces the fields it
+   * covers, and the other fields stay as read. A row the schema rejects is
+   * a `validation` error.
+   */
+  read<R extends object>(row: R): Promise<Result<R & T>>;
+  /**
+   * Validates the fields a write sets. Issues about fields the write leaves
+   * out are ignored, so partial updates pass; the database applies its
+   * defaults and `not null` checks. A rejected write is a `validation`
+   * error, and nothing is sent to the database.
+   */
+  write<A extends object>(attrs: A): Promise<Result<A>>;
+}
+/**
+ * The `fields` helper block creators use. Without a schema, reads and
+ * writes pass through unchanged.
+ */
+declare function blockFields<T extends object = Record<never, never>>(schema: StandardSchemaV1 | undefined, label: string): BlockFields<T>;
+//#endregion
+export { FieldsOf as n, blockFields as r, BlockFields as t };

package/dist/block-helpers-CKtbFcRv.d.ts

@@ -0,0 +1,37 @@
+import { t as AsyncResult, w as ErrorMapper } from "./result-D7y2fT87.js";
+import { t as BlockTransport } from "./block-transport-DvaoPuZ9.js";
+//#region src/core/block-helpers.d.ts
+/** The `temporal` option every block creator takes. */
+interface BlockTemporalOptions {
+  /**
+   * The Temporal namespace for runtimes without a global one, such as
+   * `import { Temporal } from "temporal-polyfill"`. Blocks use it instead of
+   * `globalThis.Temporal`, which stays untouched; like
+   * `defineSupabase(schema, { temporal })`, it applies to the whole process.
+   */
+  readonly temporal?: typeof Temporal;
+}
+/** The options every block creator shares. */
+interface BlockOptions extends BlockTemporalOptions {
+  /** `sqlTransport(ctx.postgres)` for members, or `rpcTransport` over an API schema. */
+  readonly transport: BlockTransport;
+  /** The transport for service-only calls (jobs, purges). Defaults to `transport`. */
+  readonly service?: BlockTransport;
+  /** The module's schema, or its API schema. Default `better_supabase`. */
+  readonly schema?: string;
+  /** Error mappers that run before the built-in ones. */
+  readonly mappers?: readonly ErrorMapper[];
+}
+/** Calls one block function and maps a rejection to a `DbError`. */
+type BlockCall = <T>(fn: string, args: Readonly<Record<string, unknown>>, then: (value: unknown) => T | Promise<T>) => AsyncResult<T>;
+/**
+ * One page of a list. `cursor` is the previous page's `next` cursor or last
+ * item, in the shape each list documents.
+ */
+interface CursorPageOptions<Cursor> {
+  /** The most items to return. Each list documents its default and maximum. */
+  readonly limit?: number;
+  readonly cursor?: Cursor;
+}
+//#endregion
+export { CursorPageOptions as i, BlockOptions as n, BlockTemporalOptions as r, BlockCall as t };

package/dist/block-helpers-DWHxHsEQ.js

@@ -0,0 +1,190 @@
+import { c as mapDbError, n as dbError } from "./errors-B11Duf73.js";
+import { l as provideTemporal } from "./temporal-BJGitm-h.js";
+import { t as temporal } from "./temporal-required-BVvW7SYJ.js";
+import { a as ok, r as err, s as toDbError, t as AsyncResult } from "./result-DzUbqgdW.js";
+import { t as fromPgError } from "./executor-De1Of3m3.js";
+import { t as rawError } from "./block-transport-BLr-ZgLc.js";
+//#region src/core/block-helpers.ts
+/** Provides `options.temporal`, when set, for the block's time values. */
+function applyTemporal(options) {
+	if (options?.temporal !== void 0) provideTemporal(options.temporal);
+}
+/** The block schema when the options name none. */
+const DEFAULT_BLOCK_SCHEMA = "better_supabase";
+/** A `BlockCall` over `transport`, in `schema`, with the app's error mappers first. */
+function blockCall(transport, schema = DEFAULT_BLOCK_SCHEMA, mappers = []) {
+	return (fn, args, then) => AsyncResult.from(async () => {
+		let value;
+		try {
+			value = await transport.call(schema, fn, args);
+		} catch (cause) {
+			const raw = rawError(cause);
+			return err(raw ? mapDbError(raw, mappers) : toDbError(cause));
+		}
+		return ok(await then(value));
+	});
+}
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const textOf = (value) => typeof value === "string" ? value : String(value);
+const optionalText = (value) => value === null || value === void 0 ? void 0 : textOf(value);
+/** A function result that must be an object. */
+function recordOf(value, fn) {
+	if (!isRecord(value)) throw new TypeError(`${fn} returned ${JSON.stringify(value)}`);
+	return value;
+}
+/** A function result that must be an array of objects. */
+function recordsOf(value, fn) {
+	if (value === null || value === void 0) return [];
+	if (!Array.isArray(value) || !value.every(isRecord)) throw new TypeError(`${fn} returned ${JSON.stringify(value)}`);
+	return value;
+}
+const stringsOf = (value) => Array.isArray(value) ? value.map(textOf) : [];
+/** `value` when it is one of `values`, otherwise `fallback`. */
+function oneOf(value, values, fallback) {
+	return values.find((item) => item === value) ?? fallback;
+}
+/** `value` when it is one of `values`; throws for anything else. */
+function enumOrThrow(value, values, what) {
+	const found = values.find((item) => item === value);
+	if (found === void 0) throw new TypeError(`unknown ${what} "${String(value)}"`);
+	return found;
+}
+/** A jsonb object column, or an empty object for anything else. */
+const recordOrEmpty = (value) => isRecord(value) ? value : {};
+/** A `credential_ref` column, or `undefined` when it names no provider. */
+function credentialRefOf(value) {
+	if (!isRecord(value) || typeof value["provider"] !== "string") return;
+	return {
+		...value,
+		provider: value["provider"]
+	};
+}
+/** The `not_found` error a block returns for a row the caller can't see. */
+const notFoundError = (message, hint) => dbError("not_found", message, hint === void 0 ? {} : { hint });
+/** A `timestamptz` from jsonb or `pg`, or `undefined` for null. */
+const optionalInstant = (value) => value === null || value === void 0 ? void 0 : value instanceof Date || typeof value === "string" ? toInstant(value) : void 0;
+/** A `timestamptz` that must be there; throws when it is null or missing. */
+function requiredInstant(value, field) {
+	const instant = optionalInstant(value);
+	if (instant === void 0) throw new TypeError(`${field} is missing`);
+	return instant;
+}
+/** An optional `timestamptz` as text for a function argument. */
+const instantArg = (value) => value === void 0 ? void 0 : value === null ? null : value.toString();
+/** SHA-256 of `value` as lowercase hex, with WebCrypto. */
+async function sha256Hex(value) {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+	return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/** `bytes` random bytes as base64url, for secrets and codes. */
+function randomToken(bytes = 24) {
+	const data = crypto.getRandomValues(new Uint8Array(bytes));
+	let binary = "";
+	for (const byte of data) binary += String.fromCodePoint(byte);
+	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function asDbError(cause) {
+	const raw = fromPgError(cause);
+	return raw ? mapDbError(raw) : toDbError(cause);
+}
+function run(fn) {
+	return AsyncResult.from(async () => {
+		try {
+			return ok(await fn());
+		} catch (cause) {
+			return err(asDbError(cause));
+		}
+	});
+}
+/**
+* The request body as text, or `undefined` once it is longer than `limit`
+* bytes. A larger `Content-Length` is refused before reading; otherwise
+* reading stops at the limit, so a body without one can't fill memory.
+*/
+async function readBodyCapped(request, limit) {
+	const length = Number(request.headers.get("content-length") ?? NaN);
+	if (Number.isFinite(length) && length > limit) return void 0;
+	if (!request.body) return "";
+	const reader = request.body.getReader();
+	const chunks = [];
+	let size = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		size += value.byteLength;
+		if (size > limit) {
+			reader.cancel().catch(() => void 0);
+			return;
+		}
+		chunks.push(value);
+	}
+	const bytes = new Uint8Array(size);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return new TextDecoder().decode(bytes);
+}
+function seconds(value) {
+	return typeof value === "number" ? `${String(value)} seconds` : value;
+}
+function workerId() {
+	return `worker-${crypto.randomUUID().slice(0, 8)}`;
+}
+/**
+* Runs `fn` over `items` with at most `limit` calls in flight. After the
+* first rejection no new item starts; the ones running finish, then it
+* rethrows.
+*/
+async function eachLimit(items, limit, fn) {
+	let next = 0;
+	let failure;
+	const lane = async () => {
+		while (failure === void 0 && next < items.length) {
+			const index = next++;
+			try {
+				await fn(items[index], index);
+			} catch (cause) {
+				failure ??= { cause };
+			}
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(Math.max(1, limit), items.length) }, lane));
+	if (failure) throw failure.cause;
+}
+const sleep = (ms, signal) => new Promise((resolve) => {
+	if (signal?.aborted) {
+		resolve();
+		return;
+	}
+	const timer = setTimeout(done, ms);
+	function done() {
+		clearTimeout(timer);
+		signal?.removeEventListener("abort", done);
+		resolve();
+	}
+	signal?.addEventListener("abort", done, { once: true });
+});
+/** pgmq and the inbox return `timestamptz` as text over RPC and as `Date` from `pg`. */
+const toInstant = (value) => value instanceof Date ? temporal().Instant.fromEpochMilliseconds(value.getTime()) : temporal().Instant.from(value);
+function errorText(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "object" && error !== null && "message" in error) return String(error.message);
+	return String(error);
+}
+function injectableOf(what, value) {
+	if (value === void 0) return void 0;
+	const version = value.apiVersion;
+	if (version !== void 0 && version !== 1) throw new TypeError(`${what} targets API ${String(version)}; this better-supabase supports 1. Upgrade better-supabase or use a release built for API 1.`);
+	return value;
+}
+/** Reads `limit` and `cursor` from a list's options. */
+function pageOf(options = {}) {
+	return {
+		limit: options.limit,
+		cursor: options.cursor
+	};
+}
+//#endregion
+export { workerId as A, run as C, stringsOf as D, sleep as E, textOf as O, requiredInstant as S, sha256Hex as T, randomToken as _, credentialRefOf as a, recordOrEmpty as b, errorText as c, isRecord as d, notFoundError as f, pageOf as g, optionalText as h, blockCall as i, toInstant as k, injectableOf as l, optionalInstant as m, applyTemporal as n, eachLimit as o, oneOf as p, asDbError as r, enumOrThrow as s, DEFAULT_BLOCK_SCHEMA as t, instantArg as u, readBodyCapped as v, seconds as w, recordsOf as x, recordOf as y };

package/dist/block-hooks-BmjMyXTa.js

@@ -0,0 +1,114 @@
+import { n as dbError, o as isDbError } from "./errors-B11Duf73.js";
+import { r as err, t as AsyncResult } from "./result-DzUbqgdW.js";
+import { t as consoleLogger } from "./logger-glM28NVN.js";
+import { i as blockCall } from "./block-helpers-DWHxHsEQ.js";
+//#region src/core/block-hooks.ts
+const isPlainObject = (value) => {
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+};
+/** A copy of plain objects and arrays; class instances (Temporal values) are immutable and stay shared. */
+function copyOf(value) {
+	if (Array.isArray(value)) return value.map(copyOf);
+	if (typeof value === "object" && value !== null && isPlainObject(value)) return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, copyOf(entry)]));
+	return value;
+}
+/** A new client with the same methods: a spread for object literals, a child object otherwise. */
+function cloneClient(client) {
+	if (isPlainObject(client)) return { ...client };
+	return Object.create(client);
+}
+/** The client's method named `name`, or undefined when it has none. */
+function methodOf(client, name) {
+	const value = client[name];
+	if (typeof value !== "function") return void 0;
+	return value;
+}
+/**
+* Runs `hooks` around a block client's methods. Use it to add a rule the
+* block doesn't know (refuse `invite` above a seat limit), rewrite arguments
+* (fill a default), or observe results (metrics, an audit line). Methods
+* without hooks are unchanged.
+*
+* ```ts
+* const orgs = withBlockHooks(createOrganizations(options), {
+*   invite: { before: ([input]) => (input.role === "owner" ? dbError("forbidden", "Owners are added by support") : undefined) },
+* });
+* ```
+*/
+function withBlockHooks(client, hooks, options = {}) {
+	if (hooks === void 0) return client;
+	const block = options.block ?? "block";
+	const logger = options.logger ?? consoleLogger;
+	const wrapped = cloneClient(client);
+	for (const [method, hook] of Object.entries(hooks)) {
+		if (hook === void 0) continue;
+		const original = methodOf(client, method);
+		if (original === void 0) throw new TypeError(`better-supabase: ${block} has no method "${method}" to hook`);
+		const { before, after } = hook;
+		const info = {
+			block,
+			method
+		};
+		wrapped[method] = (...args) => AsyncResult.from(async () => {
+			let current = args;
+			if (before) {
+				const outcome = await before(current, info);
+				if (isDbError(outcome)) return err(outcome);
+				if (Array.isArray(outcome)) current = outcome;
+			}
+			const result = await original.apply(client, current);
+			if (after) try {
+				await after(copyOf(result), current, info);
+			} catch (cause) {
+				logger.error(`${block}.${method} after hook threw`, { cause });
+			}
+			return result;
+		});
+	}
+	return wrapped;
+}
+/**
+* Adds methods to a block client. The builder gets the base client, so a
+* new method can compose existing ones, and `call` for SQL functions the
+* app adds to the block's schema. Redefining a base method throws: wrap it
+* with `withBlockHooks` instead.
+*
+* ```ts
+* const orgs = extendBlock(createOrganizations(options), (base, { call }) => ({
+*   archive: (id: string) => call("archive_organization", { id }, () => undefined),
+* }), { transport: options.transport });
+* ```
+*/
+function extendBlock(client, build, options = {}) {
+	const { transport } = options;
+	const additions = build(client, { call: transport ? blockCall(transport, options.schema ?? "better_supabase", options.mappers ?? []) : () => AsyncResult.err(dbError("unsupported", "extendBlock needs the transport option to call SQL functions")) });
+	const taken = Object.keys(additions).filter((key) => key in client);
+	if (taken.length > 0) throw new TypeError(`better-supabase: extendBlock can't redefine ${taken.map((key) => `"${key}"`).join(", ")}; wrap a base method with withBlockHooks instead`);
+	return Object.assign(cloneClient(client), additions);
+}
+/** Fills in `apiVersion: 1`. */
+function defineTransportMiddleware(middleware) {
+	return {
+		...middleware,
+		apiVersion: 1
+	};
+}
+/**
+* A transport that runs `middleware` around `transport`, the first one
+* outermost. Throws when a middleware targets an API other than 1.
+*/
+function wrapTransport(transport, ...middleware) {
+	for (const entry of middleware) {
+		const version = entry.apiVersion;
+		if (version !== 1) throw new TypeError(`better-supabase: transport middleware "${entry.name}" targets API ${String(version)}; this better-supabase supports 1`);
+	}
+	const run = middleware.reduceRight((next, entry) => (request) => entry.call(request, next), (request) => transport.call(request.schema, request.fn, request.args));
+	return { call: (schema, fn, args) => run({
+		schema,
+		fn,
+		args
+	}) };
+}
+//#endregion
+export { wrapTransport as i, extendBlock as n, withBlockHooks as r, defineTransportMiddleware as t };