better-supabase 0.4.0 → 0.5.0

package/README.md

@@ -64,6 +64,8 @@ if (!result.ok) return result; // DbError: kind, message, status, code
 | `better-supabase/hono`, `/orpc`, `/edge`                   | Framework adapters                                                       |
 | `better-supabase/mcp`                                      | MCP servers whose tools run as the signed-in user                        |
 | `better-supabase/jobs`                                     | Supabase Queues jobs, idempotency keys and a webhook inbox               |
+| `better-supabase/orgs`                                     | Organizations, members, invitations and switching from the SQL kit       |
+| `better-supabase/notifications`                            | Sending, listing and delivering notifications from the SQL kit           |
 | `better-supabase/list`                                     | Search, facets, sorting and pagination from one definition               |
 | `better-supabase/storage`, `/realtime`                     | Typed bucket paths and broadcast topics                                  |
 | `better-supabase/env`                                      | Validated Supabase settings                                              |

package/dist/channel-FQW-CnGR.d.ts

@@ -0,0 +1,70 @@
+/// <reference lib="esnext.temporal" />
+//#region src/notifications/types.d.ts
+/** A subject a notification is about, e.g. `{ type: 'task', id: '42' }`. */
+interface NotificationSubject {
+  readonly type: string;
+  readonly id: string;
+  /** Shown in the list, e.g. the task title, kept as it was at send time. */
+  readonly label?: string;
+}
+/** One notification as its recipient sees it. */
+interface NotificationItem<K extends string = string, D = unknown> {
+  /** The recipient row id: pass it to `markRead` and `dismiss`. */
+  readonly id: string;
+  /** The shared event id, the same for every recipient. */
+  readonly eventId: string;
+  readonly type: K;
+  readonly data: D;
+  readonly tenant: string | null;
+  readonly actorId: string | null;
+  readonly subject: NotificationSubject | null;
+  readonly summary: string | null;
+  readonly actionPath: string | null;
+  readonly priority: string | null;
+  readonly createdAt: Temporal.Instant;
+  readonly readAt: Temporal.Instant | null;
+  readonly resolvedAt: Temporal.Instant | null;
+}
+/** What `render` returns: the text for one notification, in one locale. */
+interface RenderedText {
+  readonly title: string;
+  readonly body?: string;
+}
+//#endregion
+//#region src/notifications/channel.d.ts
+/** One pending delivery a channel sends: the notification and who gets it. */
+interface NotificationMessage {
+  readonly deliveryId: string;
+  /** The channel name, e.g. `email`. */
+  readonly channel: string;
+  /** 1 on the first try. */
+  readonly attempts: number;
+  readonly userId: string;
+  /** The recipient's `auth.users` email, for email channels. */
+  readonly email: string | null;
+  readonly notification: NotificationItem;
+  /** What `render` returned for it, when `createNotifications` has one. */
+  readonly text?: RenderedText;
+}
+interface NotificationSendResult {
+  /** `skipped` when the channel decided not to send. Defaults to `sent`. */
+  readonly status?: "sent" | "skipped";
+  /** The provider's name, e.g. `resend` or `fcm`. */
+  readonly provider?: string;
+  /** The provider's id for the message, kept for support and webhooks. */
+  readonly providerMessageId?: string;
+}
+/**
+ * Sends notifications on one channel (email, push, Slack). The delivery
+ * worker (`notifications.deliver()`) claims pending deliveries for the
+ * channel's `name` and calls `send` for each. Throwing retries the delivery
+ * after its lease, up to `maxAttempts`, then marks it `failed`.
+ */
+interface NotificationChannel {
+  readonly apiVersion: 1;
+  /** Matches the `channel` the deliveries were created for. */
+  readonly name: string;
+  send(message: NotificationMessage): NotificationSendResult | void | Promise<NotificationSendResult | void>;
+}
+//#endregion
+export { NotificationSubject as a, NotificationItem as i, NotificationMessage as n, RenderedText as o, NotificationSendResult as r, NotificationChannel as t };

package/dist/cli/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { i as run } from "./run-CP20LKk_.js";
+import { i as run } from "./run-BKR2W_79.js";
 import { t as colorEnabled } from "./style-C0NFdJRL.js";
 import { text } from "node:stream/consumers";
 //#region src/cli/bin.ts

package/dist/cli/codemod-DqV7612m.js

@@ -0,0 +1,388 @@
+import { r as defineCliCommand } from "./command-CK14fP91.js";
+import { r as writeIfChanged } from "./io-k41_z-jT.js";
+import { i as plain, r as painter } from "./style-C0NFdJRL.js";
+import { t as fileDiff } from "./diff-SjkO5rNr.js";
+import { extname, join, relative, resolve } from "node:path";
+import { readFile, readdir, stat } from "node:fs/promises";
+//#region src/cli/codemod.ts
+const CODEMODS = {
+	"0.4": {
+		name: "0.4",
+		description: "Renames from 0.3 to 0.4 (the naming page lists them)",
+		imports: {
+			createBrowser: "createClient",
+			BetterBrowser: "BetterClient",
+			BrowserOptions: "ClientOptions",
+			BrowserAuth: "ClientAuth",
+			BetterEnv: "HonoEnv",
+			HandlerOptions: "MiddlewareOptions",
+			Queries: "BetterQueries",
+			CreateQueriesOptions: "QueriesOptions",
+			Postgres: "BetterPostgres",
+			DefineSupabaseOptions: "SupabaseOptions"
+		},
+		members: [
+			{
+				from: "serverFor",
+				to: "contextForSession"
+			},
+			{
+				from: "toORPCError",
+				to: "toOrpcError"
+			},
+			{
+				from: "$table",
+				to: "$tableName",
+				notCalled: true
+			}
+		],
+		props: [{
+			component: "BetterSupabaseProvider",
+			from: "browser",
+			to: "client"
+		}],
+		review: [
+			{
+				pattern: /\.server\(\)/,
+				message: "`next.server()` is `bs.context()` on the createNext() instance"
+			},
+			{
+				pattern: /\.handle\(\)/,
+				message: "Hono's `bs.handle()` is `bs.handler()`"
+			},
+			{
+				pattern: /\bmcp\.handler\b/,
+				message: "`mcp.handler` is `bs.endpoint`"
+			},
+			{
+				pattern: /\.sb\b/,
+				message: "`client.sb` is `client.betterSupabase`"
+			},
+			{
+				pattern: /\btestExecutor\(\s*\{[^}]*\bsb\b/,
+				message: "`{ sb }` in testExecutor is `{ betterSupabase }`"
+			}
+		]
+	},
+	"0.5": {
+		name: "0.5",
+		description: "Renames from 0.4 to 0.5: createMcp's scopes is advertisedScopes",
+		options: [{
+			call: "createMcp",
+			from: "scopes",
+			to: "advertisedScopes"
+		}]
+	}
+};
+/** `[start, end)` ranges of code, outside strings, template literals and comments. */
+function codeRanges(text) {
+	const ranges = [];
+	let start = 0;
+	let index = 0;
+	const skip = (end) => {
+		if (index > start) ranges.push([start, index]);
+		index = end;
+		start = end;
+	};
+	while (index < text.length) {
+		const char = text[index];
+		const next = text[index + 1];
+		if (char === "/" && next === "/") {
+			const end = text.indexOf("\n", index);
+			skip(end === -1 ? text.length : end);
+		} else if (char === "/" && next === "*") {
+			const end = text.indexOf("*/", index + 2);
+			skip(end === -1 ? text.length : end + 2);
+		} else if (char === "\"" || char === "'" || char === "`") {
+			let end = index + 1;
+			while (end < text.length && text[end] !== char) {
+				if (text[end] === "\\") end += 1;
+				if (char !== "`" && text[end] === "\n") break;
+				end += 1;
+			}
+			skip(text[end] === char ? end + 1 : Math.min(end, text.length));
+		} else index += 1;
+	}
+	if (index > start) ranges.push([start, index]);
+	return ranges;
+}
+function applyEdits(text, edits) {
+	let out = "";
+	let cursor = 0;
+	for (const edit of [...edits].sort((a, b) => a.start - b.start)) {
+		if (edit.start < cursor) continue;
+		out += text.slice(cursor, edit.start) + edit.text;
+		cursor = edit.end;
+	}
+	return out + text.slice(cursor);
+}
+const escapeRegExp = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function inCode(ranges, index) {
+	let low = 0;
+	let high = ranges.length - 1;
+	while (low <= high) {
+		const middle = low + high >> 1;
+		const [start, end] = ranges[middle];
+		if (index < start) high = middle - 1;
+		else if (index >= end) low = middle + 1;
+		else return true;
+	}
+	return false;
+}
+const OPENING = "({[";
+const CLOSING = ")}]";
+/** Matches of `pattern` that start in code. */
+function codeMatches(text, pattern, ranges) {
+	return [...text.matchAll(pattern)].filter((match) => inCode(ranges, match.index));
+}
+const IMPORT = /\b(import|export)\s+(type\s+)?\{([^}]*)\}\s*from\s*(["'])better-supabase(?:\/[\w./-]*)?\4/g;
+function renameImports(text, renames) {
+	const ranges = codeRanges(text);
+	const locals = /* @__PURE__ */ new Set();
+	const edits = [];
+	for (const match of codeMatches(text, IMPORT, ranges)) {
+		const list = match[3];
+		const listStart = match.index + match[0].indexOf("{") + 1;
+		const renamed = list.replaceAll(/(\btype\s+)?([\w$]+)(\s+as\s+[\w$]+)?/g, (spec, type, name, alias) => {
+			const to = renames[name];
+			if (to === void 0) return spec;
+			if (alias === void 0 && match[1] === "import") locals.add(name);
+			return `${type ?? ""}${to}${alias ?? ""}`;
+		});
+		if (renamed !== list) edits.push({
+			start: listStart,
+			end: listStart + list.length,
+			text: renamed
+		});
+	}
+	return {
+		text: applyEdits(text, edits),
+		locals
+	};
+}
+function renameIdentifiers(text, renames) {
+	if (renames.size === 0) return text;
+	const ranges = codeRanges(text);
+	const names = [...renames.keys()].map(escapeRegExp).join("|");
+	return applyEdits(text, codeMatches(text, new RegExp(`(?<![\\w$.])(?:${names})(?![\\w$])`, "g"), ranges).map((match) => ({
+		start: match.index,
+		end: match.index + match[0].length,
+		text: renames.get(match[0])
+	})));
+}
+function renameMembers(text, members) {
+	const ranges = codeRanges(text);
+	return applyEdits(text, members.flatMap((member) => codeMatches(text, new RegExp(`\\.${escapeRegExp(member.from)}(?![\\w$])${member.notCalled === true ? "(?!\\s*\\()" : ""}`, "g"), ranges).map((match) => ({
+		start: match.index,
+		end: match.index + match[0].length,
+		text: `.${member.to}`
+	}))));
+}
+function renameProps(text, props) {
+	const ranges = codeRanges(text);
+	const edits = [];
+	for (const prop of props) {
+		const tag = new RegExp(`<${escapeRegExp(prop.component)}(?![\\w$.])`, "g");
+		for (const match of codeMatches(text, tag, ranges)) {
+			let depth = 0;
+			for (let index = match.index + match[0].length; index < text.length; index += 1) {
+				if (!inCode(ranges, index)) continue;
+				const char = text[index];
+				if (char === "{") depth += 1;
+				else if (char === "}") depth -= 1;
+				else if (char === ">" && depth === 0) break;
+				if (depth === 0 && /\s/.test(text[index - 1] ?? "") && text.startsWith(`${prop.from}=`, index)) edits.push({
+					start: index,
+					end: index + prop.from.length,
+					text: prop.to
+				});
+			}
+		}
+	}
+	return applyEdits(text, edits);
+}
+/** The index after the bracket that closes the one at `open`, in code only. */
+function closing(text, open, ranges) {
+	let depth = 0;
+	for (let index = open; index < text.length; index += 1) {
+		if (!inCode(ranges, index)) continue;
+		const char = text[index];
+		if (OPENING.includes(char)) depth += 1;
+		else if (CLOSING.includes(char)) {
+			depth -= 1;
+			if (depth === 0) return index + 1;
+		}
+	}
+	return text.length;
+}
+/** Calls `visit(index, depth)` for each code character from `open` to its closing bracket. */
+function walkBrackets(text, open, ranges, visit) {
+	const end = closing(text, open, ranges);
+	let depth = 0;
+	for (let index = open; index < end; index += 1) {
+		if (!inCode(ranges, index)) continue;
+		const char = text[index];
+		if (OPENING.includes(char)) depth += 1;
+		else if (CLOSING.includes(char)) depth -= 1;
+		visit(index, depth, char);
+	}
+}
+/** Where `key` is a top-level key of the object literal at `open`. */
+function topLevelKeys(text, open, key, ranges) {
+	const keys = [];
+	let previous = "";
+	walkBrackets(text, open, ranges, (index, depth, char) => {
+		if (depth === 1 && (previous === "{" || previous === ",") && text.startsWith(key, index) && !/[\w$]/.test(text[index + key.length] ?? "")) {
+			const after = /^\s*(\S)/.exec(text.slice(index + key.length))?.[1];
+			if (after === ":") keys.push({
+				index,
+				shorthand: false
+			});
+			else if (after === "," || after === "}") keys.push({
+				index,
+				shorthand: true
+			});
+		}
+		if (depth === 1 && !/\s/.test(char)) previous = char;
+	});
+	return keys;
+}
+function renameOptions(text, options) {
+	const ranges = codeRanges(text);
+	const edits = [];
+	for (const option of options) {
+		const call = new RegExp(`(?<![\\w$.])${escapeRegExp(option.call)}\\s*(?:<[^>]*>)?\\s*\\(`, "g");
+		for (const match of codeMatches(text, call, ranges)) {
+			const objects = [];
+			walkBrackets(text, match.index + match[0].length - 1, ranges, (index, depth, char) => {
+				if (depth === 2 && char === "{") objects.push(index);
+			});
+			for (const object of objects) for (const { index, shorthand } of topLevelKeys(text, object, option.from, ranges)) edits.push({
+				start: index,
+				end: index + option.from.length,
+				text: shorthand ? `${option.to}: ${option.from}` : option.to
+			});
+		}
+	}
+	return applyEdits(text, edits);
+}
+/** Applies one codemod to a source file. */
+function applyCodemod(codemod, source) {
+	let text = source;
+	if (codemod.imports) {
+		const imported = renameImports(text, codemod.imports);
+		text = renameIdentifiers(imported.text, new Map([...imported.locals].map((name) => [name, codemod.imports[name]])));
+	}
+	if (codemod.members) text = renameMembers(text, codemod.members);
+	if (codemod.props) text = renameProps(text, codemod.props);
+	if (codemod.options) text = renameOptions(text, codemod.options);
+	const review = (codemod.review ?? []).flatMap((hint) => text.split("\n").flatMap((line, index) => hint.pattern.test(line) ? [{
+		line: index + 1,
+		message: hint.message
+	}] : []));
+	return {
+		text,
+		review
+	};
+}
+//#endregion
+//#region src/cli/commands/codemod.ts
+const CODEMOD_ARGS = {
+	name: {
+		type: "positional",
+		required: false,
+		description: "The codemod (0.4 or 0.5), then the files or directories to rewrite (default: the project)"
+	},
+	"dry-run": {
+		type: "boolean",
+		description: "Show the changes without writing them"
+	}
+};
+const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+const SKIPPED_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	".next",
+	".turbo",
+	".vercel",
+	"dist",
+	"build",
+	"coverage"
+]);
+/** Source files under `path`, skipping dependencies, build output and `.d.ts` files. */
+async function sourceFiles(path) {
+	const info = await stat(path).catch(() => void 0);
+	if (!info) return [];
+	if (info.isFile()) return [path];
+	const files = [];
+	for (const entry of await readdir(path, { withFileTypes: true })) {
+		const full = join(path, entry.name);
+		if (entry.isDirectory()) {
+			if (!SKIPPED_DIRS.has(entry.name)) files.push(...await sourceFiles(full));
+		} else if (SOURCE_EXTENSIONS.has(extname(entry.name)) && !entry.name.endsWith(".d.ts")) files.push(full);
+	}
+	return files.sort();
+}
+async function runCodemod(config, args, paint = plain) {
+	const [name, ...paths] = args._;
+	const names = Object.entries(CODEMODS).map(([key, codemod]) => `  ${key.padEnd(5)} ${codemod.description}`).join("\n");
+	if (name === void 0) return {
+		code: 2,
+		error: `Name a codemod:\n${names}`
+	};
+	const codemod = CODEMODS[name];
+	if (!codemod) return {
+		code: 2,
+		error: `Unknown codemod "${name}". Codemods:\n${names}`
+	};
+	const roots = (paths.length > 0 ? paths : ["."]).map((path) => resolve(config.root, path));
+	const files = [...new Set((await Promise.all(roots.map(sourceFiles))).flat())];
+	const dryRun = args["dry-run"] === true;
+	const changed = [];
+	const diffs = [];
+	const review = [];
+	for (const file of files) {
+		const source = await readFile(file, "utf8");
+		const result = applyCodemod(codemod, source);
+		const path = relative(config.root, file);
+		review.push(...result.review.map((hint) => ({
+			file: path,
+			...hint
+		})));
+		if (result.text === source) continue;
+		changed.push(path);
+		if (dryRun) diffs.push(fileDiff(path, source, result.text, paint));
+		else await writeIfChanged(file, result.text);
+	}
+	const lines = [...diffs, changed.length === 0 ? `Nothing to change in ${String(files.length)} files.` : `${dryRun ? "Would update" : "Updated"} ${String(changed.length)} of ${String(files.length)} files:\n${changed.map((path) => `  ${path}`).join("\n")}`];
+	if (review.length > 0) lines.push("", "Check these by hand:", ...review.map((hint) => `  ${hint.file}:${String(hint.line)}: ${hint.message}`));
+	return {
+		code: 0,
+		output: lines.join("\n"),
+		data: {
+			codemod: codemod.name,
+			dryRun,
+			changed,
+			review
+		}
+	};
+}
+const codemodCommand = defineCliCommand({
+	meta: {
+		name: "codemod",
+		description: "Rewrites imports and calls for renamed better-supabase APIs"
+	},
+	args: CODEMOD_ARGS,
+	run: (args, { config, io }) => runCodemod(config, args, painter(io.color))
+});
+//#endregion
+export { codemodCommand };

package/dist/cli/{config-D9R0o1LH.js → config-CPVpXP5I.js}

@@ -1,7 +1,7 @@
 import { n as CliError } from "./errors-4v4DTtda.js";
 import { t as display } from "./io-k41_z-jT.js";
-import { c as resolve$1, i as extname, n as basename$1, o as join$1, r as dirname$1, s as normalize$1, t as resolveModulePath } from "./dist-CFgGknmZ.js";
-import { a as literal, c as picklist, d as safeParse, f as strictObject, h as unknown, i as getDotPath, m as union, n as boolean, o as number, p as string, r as custom, s as optional, t as array, u as record } from "./dist-Du7VnEUG.js";
+import { c as resolve$1, i as extname$1, n as basename$1, o as join$1, r as dirname$1, s as normalize$1, t as resolveModulePath } from "./dist-DBPdlPYK.js";
+import { _ as unknown, a as literal, c as objectWithRest, f as record, g as union, h as string, i as getDotPath, l as optional, m as strictObject, n as boolean, o as nullable, p as safeParse, r as custom, s as number, t as array, u as picklist } from "./dist-xn4wlboc.js";
 import * as nodeUtil from "node:util";
 import { join, posix, resolve } from "node:path";
 import { existsSync, readFileSync, statSync } from "node:fs";
@@ -454,7 +454,7 @@ async function loadConfig$1(options) {
 			dir: options.cwd
 		}));
 		if (options.globalRc) {
-			const { findWorkspaceDir } = await import("./dist-B1MvLv-M.js");
+			const { findWorkspaceDir } = await import("./dist-DreZ24Sz.js");
 			const workspaceDir = await findWorkspaceDir(options.cwd).catch(() => {});
 			if (workspaceDir) rcSources.push(read({
 				name: options.rcFile,
@@ -470,7 +470,7 @@ async function loadConfig$1(options) {
 	}
 	if (options.packageJson) {
 		const keys = (Array.isArray(options.packageJson) ? options.packageJson : [typeof options.packageJson === "string" ? options.packageJson : options.name]).filter((t) => t && typeof t === "string");
-		const { readPackageJSON } = await import("./dist-B1MvLv-M.js");
+		const { readPackageJSON } = await import("./dist-DreZ24Sz.js");
 		const pkgJsonFile = await readPackageJSON(options.cwd).catch(() => {});
 		rawConfigs.packageJson = _merger({}, ...keys.map((key) => pkgJsonFile?.[key]));
 	}
@@ -602,7 +602,7 @@ async function resolveConfig$1(source, options, sourceOptions = {}) {
 		})).dir;
 	}
 	if (NPM_PACKAGE_RE.test(source)) source = tryResolve(source, options) || source;
-	const ext = extname(source);
+	const ext = extname$1(source);
 	const isDir = _isDirectory(resolve$1(options.cwd, source)) ?? (!ext || ext === basename$1(source));
 	const cwd = resolve$1(options.cwd, isDir ? source : dirname$1(source));
 	if (isDir) source = options.configFile;
@@ -616,7 +616,7 @@ async function resolveConfig$1(source, options, sourceOptions = {}) {
 	res.configFile = tryResolve(resolve$1(cwd, source), options) || tryResolve(resolve$1(cwd, ".config", source.replace(/\.config$/, "")), options) || tryResolve(resolve$1(cwd, ".config", source), options) || source;
 	if (!existsSync(res.configFile)) return res;
 	res._configFile = res.configFile;
-	const configFileExt = extname(res.configFile) || "";
+	const configFileExt = extname$1(res.configFile) || "";
 	if (configFileExt in ASYNC_LOADERS) res.config = (await ASYNC_LOADERS[configFileExt]())(await readFile(res.configFile, "utf8"));
 	else {
 		const _resolveModule = options.resolveModule || ((mod) => mod.default || mod);
@@ -696,6 +696,56 @@ const isGenerator = (value) => typeof value === "object" && value !== null && "n
 * checks the leaves a typo or an old value breaks; nested objects the
 * library reads loosely stay loose.
 */
+const kitModuleEntries = {
+	mode: optional(picklist([
+		"managed",
+		"adopt",
+		"custom"
+	])),
+	schema: optional(string()),
+	tables: optional(record(string(), nullable(string()))),
+	columns: optional(record(string(), record(string(), nullable(string())))),
+	idType: optional(string()),
+	permissions: optional(stringRecord),
+	options: optional(record(string(), unknown())),
+	hooks: optional(strictObject({
+		schema: optional(string()),
+		functions: optional(stringRecord)
+	})),
+	events: optional(boolean())
+};
+const accessKit = strictObject({
+	...kitModuleEntries,
+	model: optional(picklist([
+		"roles",
+		"catalog",
+		"permdock",
+		"custom"
+	])),
+	roles: optional(record(string(), strings)),
+	functions: optional(strictObject({
+		can: optional(string()),
+		tenantIdsWith: optional(string()),
+		isPlatform: optional(string()),
+		canUser: optional(string()),
+		canAssign: optional(string()),
+		permissionClaims: optional(string())
+	})),
+	platformClaim: optional(string()),
+	disabled: optional(strictObject({
+		tenant: optional(string()),
+		user: optional(string()),
+		userKey: optional(string())
+	})),
+	activeTenant: optional(union([picklist(["claim", "resolver"]), strictObject({
+		profileColumn: string(),
+		key: optional(string())
+	})])),
+	permdock: optional(strictObject({
+		schema: optional(string()),
+		scope: optional(string())
+	}))
+});
 const ConfigSchema = strictObject({
 	$schema: optional(string()),
 	source: optional(strictObject({
@@ -744,7 +794,10 @@ const ConfigSchema = strictObject({
 	})),
 	buckets: optional(record(string(), record(string(), unknown()))),
 	topics: optional(stringRecord),
-	realtime: optional(strictObject({ tables: optional(strings) })),
+	realtime: optional(strictObject({
+		tables: optional(strings),
+		global: optional(strings)
+	})),
 	entitlements: optional(strictObject({
 		customer: optional(string()),
 		key: optional(string()),
@@ -768,6 +821,7 @@ const ConfigSchema = strictObject({
 		testsDir: optional(string()),
 		kit: optional(strings)
 	})),
+	kits: optional(objectWithRest({ access: optional(accessKit) }, strictObject(kitModuleEntries))),
 	seed: optional(strictObject({
 		entry: optional(string()),
 		output: optional(string())
@@ -1747,6 +1801,22 @@ function pgFunctionHooks(document) {
 		}] : [];
 	});
 }
+/** The enabled Auth hooks with an `http://` or `https://` URI, by hook name. */
+function httpHooks(document) {
+	const hooks = tomlGet(document, ["auth", "hook"]);
+	if (typeof hooks !== "object" || Array.isArray(hooks)) return [];
+	return Object.entries(hooks).flatMap(([hook, table]) => {
+		if (typeof table !== "object" || Array.isArray(table)) return [];
+		const { enabled, uri, secrets } = table;
+		if (enabled !== true && enabled !== "true" || typeof uri !== "string") return [];
+		if (!/^https?:\/\//i.test(uri.trim()) || !URL.canParse(uri.trim())) return [];
+		return [{
+			hook,
+			uri: new URL(uri.trim()),
+			secrets: typeof secrets === "string" ? secrets : void 0
+		}];
+	});
+}
 /** pg-delta when `[experimental.pgdelta] enabled = true`, otherwise the legacy migra engine. */
 function diffEngine(toml) {
 	const enabled = tomlGet(toml?.document ?? {}, [
@@ -1892,4 +1962,4 @@ async function databaseUrl(config, env, fromStdin) {
 	return `postgresql://postgres:postgres@127.0.0.1:${await readSupabasePort(config.root, "db") ?? 54322}/postgres`;
 }
 //#endregion
-export { loadConfig as a, diffEngine as c, readSupabaseToml as d, schemaPaths as f, importModule as i, migrationCommand as l, findConfig as n, readSupabasePort as o, tomlGet as p, importExport as r, stdinDatabaseUrl as s, databaseUrl as t, pgFunctionHooks as u };
+export { loadConfig as a, diffEngine as c, pgFunctionHooks as d, readSupabaseToml as f, importModule as i, httpHooks as l, tomlGet as m, findConfig as n, readSupabasePort as o, schemaPaths as p, importExport as r, stdinDatabaseUrl as s, databaseUrl as t, migrationCommand as u };

package/dist/cli/{config-SSKSTUl2.js → config-dtoekM0v.js}

@@ -1,2 +1,2 @@
-import { a as loadConfig, i as importModule, n as findConfig, o as readSupabasePort, r as importExport, s as stdinDatabaseUrl, t as databaseUrl } from "./config-D9R0o1LH.js";
+import { a as loadConfig, i as importModule, n as findConfig, o as readSupabasePort, r as importExport, s as stdinDatabaseUrl, t as databaseUrl } from "./config-CPVpXP5I.js";
 export { databaseUrl, findConfig, importExport, importModule, loadConfig, readSupabasePort, stdinDatabaseUrl };