better-supabase 0.7.1 → 0.9.0

package/dist/cli/version-DNRW4DAP.js

@@ -0,0 +1,4 @@
+//#region src/cli/version.ts
+const VERSION = "0.9.0";
+//#endregion
+export { VERSION as t };

package/dist/cli/write-BS6F3Yvz.js

@@ -0,0 +1,180 @@
+import { n as CliError } from "./errors-Caiz_0so.js";
+import { t as display } from "./io-BiPX-_J1.js";
+import { b as sqlPlan, c as writeLatestMigration, o as renderModuleMigration, p as writeExtensionsMigration, t as MODULES_SUFFIX, u as DATA_NEXT } from "./module-migration-YFFdWC5X.js";
+import { d as readSupabaseToml, f as schemaPaths, h as tomlGet, i as diffEngine, l as migrationCommand, o as findSupabaseRoot, p as sqlWorkflow, t as PGDELTA_TABLE } from "./supabase-toml-DjLgBYEo.js";
+import { n as applyPlan, r as changeLines } from "./files-DDvAwTko.js";
+import { t as loadTopics } from "./topics-GJuIDwlY.js";
+import { dirname, join, resolve } from "node:path";
+import { readFile, readdir } from "node:fs/promises";
+import { APP_TABLES_MARKER, APP_TABLES_MODULE, moduleTopics, renderModules, resolveModules, sameModuleFile } from "better-supabase/sql";
+import { CONFIG_DEFAULTS } from "better-supabase/config";
+//#region src/cli/enable-pgdelta.ts
+/**
+* Adds `[experimental.pgdelta] enabled = true` to `supabase/config.toml`
+* when it has no such table, so `supabase db schema declarative sync`
+* runs on pg-delta. A table set to `enabled = false` is left alone, and a
+* project without `config.toml` gets nothing.
+*/
+async function enablePgDelta(root, dryRun, base = root) {
+	const supabaseRoot = findSupabaseRoot(root);
+	const toml = await readSupabaseToml(root);
+	if (supabaseRoot === void 0 || toml === void 0) return [];
+	const path = join(supabaseRoot, "supabase/config.toml");
+	const shown = display(base, path);
+	if (diffEngine(toml) === "pg-delta") return [];
+	if (tomlGet(toml.document, ["experimental", "pgdelta"]) !== void 0 || toml.text.includes("pgdelta")) return [`Skipped ${shown} (pg-delta is off; set [experimental.pgdelta] enabled = true, remove [db.migrations] schema_paths and use \`supabase db schema declarative sync\` instead of \`supabase db diff\`)`];
+	const separator = toml.text === "" || toml.text.endsWith("\n\n") ? "" : toml.text.endsWith("\n") ? "\n" : "\n\n";
+	await applyPlan({
+		root: dirname(path),
+		regenerate: "better-supabase init",
+		files: [{
+			path,
+			contents: `${toml.text}${separator}${PGDELTA_TABLE}`,
+			policy: "edit"
+		}]
+	}, { "dry-run": dryRun });
+	return [`${dryRun ? "Would enable" : "Enabled"} pg-delta in ${shown}`];
+}
+//#endregion
+//#region src/cli/topic-policies.ts
+const literalParts = (template) => template.replaceAll(/\{[^}]+\}/g, "{}");
+const owns = (owned, template) => owned.endsWith("*") ? template.startsWith(owned.slice(0, -1)) : literalParts(owned) === literalParts(template);
+const receivesOnly = (sql) => !sql.includes(" for insert ") && !sql.includes("'presence'");
+/** The file `realtime.policies` writes, or `undefined` when it isn't set. */
+async function topicPolicyFile(config, owned = []) {
+	const policies = config.realtime.policies;
+	const triggers = config.realtime.triggers;
+	if (policies === void 0) {
+		if (triggers.length > 0) throw new CliError("config_invalid", "realtime.triggers needs realtime.policies: the triggers go to its output, for topics its from files export");
+		return;
+	}
+	if (triggers.length > 0 && !config.blockNames.includes("realtime-tables")) throw new CliError("config_invalid", "realtime.triggers call better_supabase.broadcast_topic(): add realtime-tables to blocks");
+	const topics = (await loadTopics(config.root, policies.from)).map((each) => each.topic);
+	const functions = config.authorization?.functions;
+	const sqlOf = (topic) => topic.sql(functions === void 0 ? void 0 : { functions });
+	const skipped = [];
+	const written = topics.filter((topic) => {
+		const owner = owned.find((entry) => owns(entry.topic, topic.template));
+		if (owner === void 0 || !receivesOnly(sqlOf(topic))) return true;
+		skipped.push(`-- Skipped topic ${topic.template}: the ${owner.module} module writes its receive policy.`);
+		return false;
+	});
+	const triggerSql = triggers.map(({ topic: template, table, ...options }) => {
+		const topic = topics.find((candidate) => candidate.template === template);
+		if (topic === void 0) throw new CliError("config_invalid", `realtime.triggers: no topic "${template}" in ${policies.from.join(", ")}`);
+		return topic.trigger(table, options);
+	});
+	const header = [
+		"-- better-supabase: realtime topic policies",
+		`-- Written by \`better-supabase sql sync\` from ${policies.from.join(", ")}; edit the topics, not this file.`,
+		...skipped
+	].join("\n");
+	return {
+		path: policies.output,
+		contents: `${header}\n\n${[...written.map(sqlOf), ...triggerSql].join("\n")}`
+	};
+}
+//#endregion
+//#region src/cli/sql/write.ts
+const MODULE_TEST_MARKER = /^-- @bs-module-test ([a-z0-9-]+)$/m;
+/**
+* Test files a SQL module wrote for an earlier layout (a table that is no
+* longer audited), for the modules in `names`. With `appTables`, also the
+* app tables files once `appTables` is empty.
+*/
+async function staleModuleTests(config, names, sqlLayout, files, appTables = true) {
+	const dir = (sqlLayout.testsDir ?? CONFIG_DEFAULTS.sql.testsDir).replace(/\/$/, "");
+	const entries = await readdir(resolve(config.root, dir)).catch(() => []);
+	const current = new Set(files.map((file) => file.path));
+	const modules = /* @__PURE__ */ new Set([...resolveModules(names, sqlLayout).map((module) => module.name), ...appTables ? [APP_TABLES_MODULE] : []]);
+	const stale = appTables ? await staleAppTablesSchema(config, sqlLayout, current) : [];
+	for (const name of entries.toSorted()) {
+		const path = `${dir}/${name}`;
+		if (!name.endsWith(".test.sql") || current.has(path)) continue;
+		const text = await readFile(resolve(config.root, path), "utf-8");
+		const module = MODULE_TEST_MARKER.exec(text)?.[1];
+		if (module !== void 0 && modules.has(module)) stale.push(path);
+	}
+	return stale;
+}
+/** The app tables schema file, when `appTables` no longer renders it. */
+async function staleAppTablesSchema(config, sqlLayout, current) {
+	const path = `${(sqlLayout.dir ?? CONFIG_DEFAULTS.sql.dir).replace(/\/$/, "")}/${sqlLayout.prefix ?? CONFIG_DEFAULTS.sql.prefix}_app_tables.sql`;
+	if (current.has(path)) return [];
+	return (await readFile(resolve(config.root, path), "utf-8").catch(() => "")).split("\n").includes(APP_TABLES_MARKER) ? [path] : [];
+}
+/** A rendered module file as a plan entry, compared without its module version. */
+const moduleFile = (file) => ({
+	path: file.path,
+	contents: file.contents,
+	note: file.module,
+	same: sameModuleFile
+});
+async function write(config, args, names, sqlLayout, now, only, upgrade = []) {
+	const workflow = sqlWorkflow(config, await readSupabaseToml(config.root));
+	const migrations = workflow === "migrations";
+	const lines = [];
+	const dryRun = args["dry-run"] === true;
+	const rendered = renderModules(names, sqlLayout);
+	const files = rendered.filter((file) => only === void 0 || only.includes(file.module));
+	const written = files.filter((file) => !migrations || file.kind === "test");
+	const applied = await applyPlan(sqlPlan(config, {
+		regenerate: "better-supabase sql sync",
+		files: written.map((file) => moduleFile(file)),
+		remove: await staleModuleTests(config, only ?? names, sqlLayout, files, only === void 0)
+	}), { "dry-run": dryRun });
+	lines.push(...changeLines(applied));
+	const data = !dryRun && applied.changes.some((change, index) => (change.outcome === "create" || change.outcome === "update") && written[index]?.kind === "data");
+	if (migrations) {
+		const topics = await topicPolicyFile(config, moduleTopics(names, sqlLayout));
+		const written = await writeLatestMigration(config, MODULES_SUFFIX, renderModuleMigration({
+			files: rendered,
+			upgrade,
+			...topics === void 0 ? {} : { topics: topics.contents }
+		}), {
+			now: now(),
+			dryRun,
+			force: upgrade.length > 0
+		});
+		lines.push(written.line);
+		return lines;
+	}
+	lines.push(...await writeExtensionsMigration(config, files, dryRun, now));
+	if (data) lines.push("", DATA_NEXT);
+	if (workflow === "pg-delta") lines.push(...await enablePgDelta(config.root, dryRun));
+	return lines;
+}
+/** The command that takes the written modules to the database. */
+async function nextStep(config) {
+	const workflow = sqlWorkflow(config, await readSupabaseToml(config.root));
+	return workflow === "migrations" ? {
+		command: migrationCommand(workflow),
+		when: "applies the migration"
+	} : {
+		command: migrationCommand(workflow, "better_supabase_module"),
+		when: "creates a migration from the module files"
+	};
+}
+/** A note when migra's `schema_paths` is set and misses module files, which `supabase db diff` would then skip. */
+async function unlistedModuleFiles(config, names, sqlLayout) {
+	const toml = await readSupabaseToml(config.root);
+	const workflow = sqlWorkflow(config, toml);
+	if (workflow !== "migra") return [];
+	const order = await schemaPaths(config.root, toml, workflow);
+	if (!order.configured) return [];
+	const supabase = `${toml?.dir ?? "supabase"}/`;
+	const unlisted = new Set(order.unlisted);
+	const listed = new Set(order.files.filter((path) => !unlisted.has(path)));
+	const dir = `${config.sql.dir.replace(/\/$/, "")}/`;
+	const missing = renderModules(names, sqlLayout).filter((file) => file.kind !== "data").map((file) => file.path).filter((path) => path.startsWith(dir) && !listed.has(path));
+	if (missing.length === 0) return [];
+	return [
+		"",
+		`${toml?.path ?? "supabase/config.toml"} sets [db.migrations] schema_paths, and no entry matches these files, so \`supabase db diff\` skips them.`,
+		"Add them before the schemas that call their functions:",
+		...missing.map((path) => `  "./${path.startsWith(supabase) ? path.slice(supabase.length) : path}",`),
+		"Or switch to pg-delta, which orders the files by dependency: add [experimental.pgdelta] with enabled = true and remove schema_paths (doctor BS316)."
+	];
+}
+//#endregion
+export { write as a, unlistedModuleFiles as i, nextStep as n, topicPolicyFile as o, staleModuleTests as r, enablePgDelta as s, moduleFile as t };

package/dist/client/index.d.ts

@@ -1,3 +1,7 @@
-import { a as ClientAuth, i as BindClientOptions, n as AuthUser, o as bindClient, r as BetterClient, t as AuthSnapshot } from "../bind-Bu_ZNa3W.js";
-import { n as createClient, t as ClientOptions } from "../index-BkWT_uBO.js";
-export { type AuthSnapshot, type AuthUser, type BetterClient, type BindClientOptions, type ClientAuth, ClientOptions, bindClient, createClient };
+import { n as TopicPort, r as TopicWatch, t as TopicHandle } from "../watch-topic-EFpOIIDE.js";
+import { a as PickFilesOptions, c as Shortcut, d as UploadPort, f as memoryStorage, i as KeyboardPort, l as StoragePort, n as DeepLinkPort, o as PickedFile, p as storageUpload, r as FilePickerPort, s as PushTokenPort, t as ClientPorts, u as UploadDestination } from "../ports-DAdQyjZz.js";
+import { a as ClientAuth, i as BindClientOptions, n as AuthUser, o as bindClient, r as BetterClient, t as AuthSnapshot } from "../bind-a7sUgvf4.js";
+import { a as defineController, i as ControllerState, n as Controller, o as whileSignedIn, r as ControllerParts, t as AuthPort } from "../controller-D845qKh2.js";
+import { n as FunctionContract } from "../function-contract-B4c0XuTU.js";
+import { a as webDeepLinks, c as webPorts, d as FunctionContracts, f as FunctionsHost, h as functions, i as WebPushTokenOptions, l as webPushToken, m as TypedFunctions, n as createClient, o as webFilePicker, p as InvokeOptions, r as PushRegistrationLike, s as webKeyboard, t as ClientOptions, u as webStorage } from "../index-BkzNUPId.js";
+export { type AuthPort, type AuthSnapshot, type AuthUser, type BetterClient, type BindClientOptions, type ClientAuth, ClientOptions, type ClientPorts, type Controller, type ControllerParts, type ControllerState, type DeepLinkPort, type FilePickerPort, type FunctionContract, type FunctionContracts, type FunctionsHost, type InvokeOptions, type KeyboardPort, type PickFilesOptions, type PickedFile, type PushRegistrationLike, type PushTokenPort, type Shortcut, type StoragePort, type TopicHandle, type TopicPort, type TopicWatch, type TypedFunctions, type UploadDestination, type UploadPort, type WebPushTokenOptions, bindClient, createClient, defineController, functions, memoryStorage, storageUpload, webDeepLinks, webFilePicker, webKeyboard, webPorts, webPushToken, webStorage, whileSignedIn };

package/dist/client/index.js

@@ -1,7 +1,202 @@
+import { n as dbError } from "../errors-8i6tSICm.js";
+import { a as ok, r as err, t as AsyncResult } from "../result-BlgnMB0H.js";
+import { i as isProblem, r as fromProblem } from "../problem-pIiL3WbE.js";
 import { EnvValidationError, parseEnv } from "../env/index.js";
-import { t as bindClient } from "../bind-l4kAvYSv.js";
+import { n as storageUpload, r as bindClient, t as memoryStorage } from "../ports-DGK3KTDH.js";
+import { n as whileSignedIn, t as defineController } from "../controller-D6NyNrlZ.js";
 import { createBrowserClient } from "@supabase/ssr";
-import { createClient as createClient$1 } from "@supabase/supabase-js";
+import { FunctionsFetchError, FunctionsHttpError, FunctionsRelayError, createClient as createClient$1 } from "@supabase/supabase-js";
+//#region src/client/web-ports.ts
+function keyEvent(event) {
+	if (typeof event !== "object" || event === null || !("key" in event) || typeof event.key !== "string") return;
+	return event;
+}
+const browser = () => globalThis;
+/** Reading `localStorage` throws where the browser blocks it. */
+function storageOf(kind) {
+	return kind === "local" ? browser().localStorage : browser().sessionStorage;
+}
+/**
+* The storage port over `localStorage` (or `sessionStorage`). Reads resolve
+* with `null` and writes do nothing where storage is missing or blocked.
+*/
+function webStorage(kind = "local") {
+	const run = (apply, fallback) => {
+		try {
+			const storage = storageOf(kind);
+			return Promise.resolve(storage ? apply(storage) : fallback);
+		} catch {
+			return Promise.resolve(fallback);
+		}
+	};
+	return {
+		get: (key) => run((storage) => storage.getItem(key), null),
+		set: (key, value) => run((storage) => {
+			storage.setItem(key, value);
+		}, void 0),
+		remove: (key) => run((storage) => {
+			storage.removeItem(key);
+		}, void 0)
+	};
+}
+/** The keyboard port over `keydown` on `window`; `mod` matches Cmd and Ctrl. */
+function webKeyboard() {
+	return (shortcut, run) => {
+		const target = browser().window;
+		if (!target) return () => void 0;
+		const onKey = (raw) => {
+			const event = keyEvent(raw);
+			if (event === void 0 || event.key.toLowerCase() !== shortcut.key.toLowerCase() || (event.metaKey || event.ctrlKey) !== (shortcut.mod ?? false) || event.shiftKey !== (shortcut.shift ?? false) || event.altKey !== (shortcut.alt ?? false)) return;
+			event.preventDefault();
+			run();
+		};
+		target.addEventListener("keydown", onKey);
+		return () => {
+			target.removeEventListener("keydown", onKey);
+		};
+	};
+}
+function pickedFile(file) {
+	return {
+		name: file.name,
+		type: file.type === "" ? void 0 : file.type,
+		size: file.size,
+		uri: void 0,
+		read: () => Promise.resolve(file)
+	};
+}
+/** The file picker port over a hidden `<input type="file">`. */
+function webFilePicker() {
+	return (options = {}) => new Promise((resolve) => {
+		const page = browser().document;
+		if (!page) {
+			resolve([]);
+			return;
+		}
+		const input = page.createElement("input");
+		input.type = "file";
+		input.multiple = options.multiple ?? false;
+		if (options.accept) input.accept = options.accept.join(",");
+		input.addEventListener("change", () => {
+			resolve([...input.files ?? []].map(pickedFile));
+		});
+		input.addEventListener("cancel", () => {
+			resolve([]);
+		});
+		input.click();
+	});
+}
+/** The deep link port over `location`, `popstate` and `hashchange`. */
+function webDeepLinks() {
+	return {
+		initial: () => Promise.resolve(browser().window?.location.href ?? null),
+		subscribe: (listener) => {
+			const target = browser().window;
+			if (!target) return () => void 0;
+			const onChange = () => {
+				listener(target.location.href);
+			};
+			target.addEventListener("popstate", onChange);
+			target.addEventListener("hashchange", onChange);
+			return () => {
+				target.removeEventListener("popstate", onChange);
+				target.removeEventListener("hashchange", onChange);
+			};
+		}
+	};
+}
+function keyBytes(base64url) {
+	const base64 = base64url.replaceAll("-", "+").replaceAll("_", "/");
+	const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+	return Uint8Array.from(atob(padded), (char) => char.codePointAt(0) ?? 0);
+}
+/**
+* The push token port over the Push API: the token is the JSON of the
+* browser's push subscription, which a Web Push sender needs.
+*/
+function webPushToken(options) {
+	return {
+		provider: "webpush",
+		token: async ({ request = true } = {}) => {
+			const notification = browser().Notification;
+			const worker = browser().navigator?.serviceWorker;
+			if (!notification || !worker) return null;
+			let permission = notification.permission;
+			if (permission === "default" && request) permission = await notification.requestPermission();
+			if (permission !== "granted") return null;
+			const registration = await (options.registration?.() ?? worker.ready);
+			const subscription = await registration.pushManager.getSubscription() ?? await registration.pushManager.subscribe({
+				userVisibleOnly: true,
+				applicationServerKey: keyBytes(options.vapidPublicKey)
+			});
+			return JSON.stringify(subscription);
+		}
+	};
+}
+/** The web ports `createClient` uses: storage, the keyboard, the file picker and deep links. */
+function webPorts() {
+	return {
+		storage: webStorage(),
+		keyboard: webKeyboard(),
+		files: webFilePicker(),
+		links: webDeepLinks()
+	};
+}
+//#endregion
+//#region src/client/functions.ts
+function withJson(headers = {}) {
+	return Object.keys(headers).some((key) => key.toLowerCase() === "content-type") ? { ...headers } : {
+		...headers,
+		"content-type": "application/json"
+	};
+}
+function causeName(cause) {
+	return cause instanceof Error ? cause.name : void 0;
+}
+async function fromHttp(response, name) {
+	if ((response.headers.get("content-type") ?? "").includes("json")) {
+		const body = await response.json().catch(() => void 0);
+		if (isProblem(body)) return fromProblem(body);
+	}
+	return dbError("unexpected", `${name} answered ${String(response.status)}`, { status: response.status });
+}
+/** The function's error as a `DbError`. */
+async function toFunctionError(error, name) {
+	if (error instanceof FunctionsHttpError && error.context instanceof Response) return fromHttp(error.context, name);
+	if (error instanceof FunctionsFetchError) {
+		const cause = error.context;
+		if (causeName(cause) === "AbortError") return dbError("aborted", `The call to ${name} was aborted`);
+		if (causeName(cause) === "TimeoutError") return dbError("timeout", `The call to ${name} timed out`);
+		return dbError("network", `Could not reach ${name}`);
+	}
+	if (error instanceof FunctionsRelayError) return dbError("network", `The Edge Functions relay failed to run ${name}`);
+	return dbError("unexpected", error instanceof Error ? error.message : `${name} failed`);
+}
+/**
+* Typed Edge Function calls over supabase-js's `functions` client. The
+* contracts come from the functions' own code, imported as types:
+*
+* ```ts
+* import type { SendInvite } from "../supabase/functions/send-invite/index.ts";
+*
+* const fns = functions<{ "send-invite": SendInvite }>(supabase);
+* const invite = await fns.invoke("send-invite", { email }).orThrow();
+* ```
+*/
+function functions(host) {
+	return { invoke(name, ...[input, options]) {
+		return AsyncResult.from(async () => {
+			const { data, error, response } = await host.functions.invoke(name, input === void 0 ? options : {
+				...options,
+				headers: withJson(options?.headers),
+				body: JSON.stringify(input)
+			});
+			if (error !== null && error !== void 0) return err(await toFunctionError(error, name));
+			return ok(response?.status === 204 ? void 0 : data);
+		});
+	} };
+}
+//#endregion
 //#region src/client/index.ts
 function clientFor(options) {
 	if (options.client) return options.client;
@@ -29,7 +224,15 @@ function clientFor(options) {
 * ```
 */
 function createClient(betterSupabase, options = {}) {
-	return bindClient(betterSupabase, clientFor(options), options.staleTime === void 0 ? {} : { staleTime: options.staleTime });
+	const supabase = clientFor(options);
+	return bindClient(betterSupabase, supabase, {
+		...options.staleTime === void 0 ? {} : { staleTime: options.staleTime },
+		ports: {
+			...webPorts(),
+			upload: storageUpload(supabase),
+			...options.ports
+		}
+	});
 }
 //#endregion
-export { bindClient, createClient };
+export { bindClient, createClient, defineController, functions, memoryStorage, storageUpload, webDeepLinks, webFilePicker, webKeyboard, webPorts, webPushToken, webStorage, whileSignedIn };

package/dist/client/native/index.d.ts

@@ -1,7 +1,11 @@
-import { t as AsyncResult } from "../../result-D7y2fT87.js";
-import { S as UploadOptions, x as UploadBody } from "../../bucket-Cl46E3jS.js";
-import { a as ClientAuth, i as BindClientOptions, n as AuthUser, o as bindClient, r as BetterClient, t as AuthSnapshot } from "../../bind-Bu_ZNa3W.js";
+import { t as AsyncResult } from "../../result-Cj3yWhjH.js";
+import { H as UploadOptions, V as UploadBody } from "../../storage-api-Cx-1iWBd.js";
+import { n as TopicPort, r as TopicWatch, t as TopicHandle } from "../../watch-topic-EFpOIIDE.js";
+import { a as PickFilesOptions, c as Shortcut, d as UploadPort, f as memoryStorage, i as KeyboardPort, l as StoragePort, n as DeepLinkPort, o as PickedFile, p as storageUpload, r as FilePickerPort, s as PushTokenPort, t as ClientPorts, u as UploadDestination } from "../../ports-DAdQyjZz.js";
+import { a as ClientAuth, i as BindClientOptions, n as AuthUser, o as bindClient, r as BetterClient, t as AuthSnapshot } from "../../bind-a7sUgvf4.js";
+import { n as ExpoPushTokenOptions, r as expoPushToken, t as ExpoNotificationsLike } from "../../push-token-asrmi7-6.js";
 import { a as OAuthSignInOptions, c as linkParams, i as OAuthClient, l as signInWithOAuthBrowser, n as AuthLinkClient, o as WebBrowserLike, r as AuthLinkResult, s as handleAuthDeepLink, t as AuthFailure } from "../../auth-link-BjFPqwLz.js";
+import { SupabaseClient } from "@supabase/supabase-js";
 //#region src/client/native/auto-refresh.d.ts
 /** The part of React Native's `AppState` that `autoRefreshOnForeground` uses. */
 interface AppStateLike {
@@ -52,6 +56,69 @@ interface KeyValue {
 }
 export declare function keyValue(store: KeyValueStoreLike): KeyValue;
 //#endregion
+//#region src/client/native/ports.d.ts
+/** The storage port over AsyncStorage, MMKV or any async string store. */
+export declare function nativeStorage(store: KeyValueStoreLike): StoragePort;
+/** The part of `expo-linking` (or React Native's `Linking`) the deep link port uses. */
+interface LinkingLike {
+  getInitialURL(): Promise<string | null>;
+  addEventListener(type: "url", listener: (event: {
+    readonly url: string;
+  }) => void): {
+    remove(): void;
+  };
+}
+/** The deep link port over `expo-linking`. */
+export declare function nativeDeepLinks(linking: LinkingLike): DeepLinkPort;
+/** One asset of an `expo-document-picker` result. */
+interface DocumentPickerAsset {
+  readonly uri: string;
+  readonly name: string;
+  readonly mimeType?: string | undefined;
+  readonly size?: number | undefined;
+}
+/** The part of `expo-document-picker` the file picker port uses. */
+interface DocumentPickerLike {
+  getDocumentAsync(options?: {
+    readonly type?: string | string[];
+    readonly multiple?: boolean;
+    readonly copyToCacheDirectory?: boolean;
+  }): Promise<{
+    readonly canceled: true;
+    readonly assets: null;
+  } | {
+    readonly canceled: false;
+    readonly assets: readonly DocumentPickerAsset[];
+  }>;
+}
+/**
+ * The file picker port over `expo-document-picker`. Files are read through
+ * `fetch`, which reads `file://` and `content://` URIs on React Native.
+ */
+export declare function nativeFilePicker(picker: DocumentPickerLike, read?: (uri: string) => Promise<Response>): FilePickerPort;
+interface NativePortsOptions {
+  /** Uploads picked files to Supabase Storage. */
+  readonly supabase?: Pick<SupabaseClient, "storage">;
+  /** AsyncStorage or MMKV, for the storage port. */
+  readonly storage?: KeyValueStoreLike;
+  /** `expo-linking`, for the deep link port. */
+  readonly linking?: LinkingLike;
+  /** `expo-notifications`, for the push token port. */
+  readonly notifications?: ExpoNotificationsLike;
+  readonly projectId?: string | undefined;
+  /** `expo-document-picker`, for the file picker port. */
+  readonly documentPicker?: DocumentPickerLike;
+}
+/**
+ * The React Native ports, from the Expo modules the app installs. Pass the
+ * result to `createNativeClient(betterSupabase, supabase, { ports })`.
+ *
+ * ```ts
+ * const ports = nativePorts({ supabase, storage: AsyncStorage, linking: Linking, notifications: Notifications });
+ * ```
+ */
+export declare function nativePorts(options: NativePortsOptions): ClientPorts;
+//#endregion
 //#region src/client/native/storage.d.ts
 /** The part of `expo-secure-store` the storage adapter uses. */
 interface SecureStoreLike {
@@ -225,4 +292,4 @@ export declare function contentTypeOf(uri: string): string | undefined;
  */
 export declare function uploadFromUri<T, R>(bucket: UriUploadTarget<T, R>, target: T, uri: string, options?: UploadFromUriOptions): AsyncResult<R>;
 //#endregion
-export { type AesCryptoLike, type AppStateLike, type AsyncStorageLike, type AuthFailure, type AuthLinkClient, type AuthLinkResult, type AuthSnapshot, type AuthStorage, type AuthUser, type AutoRefreshClient, type BetterClient, type BindClientOptions, type ClientAuth, type FocusManagerLike, type KeyValue, type KeyValueStoreLike, type LargeSecureStorageOptions, type MmkvLike, type NetInfoLike, type OAuthClient, type OAuthSignInOptions, type OnlineManagerLike, type PersistQueryCacheOptions, type QueryPersister, type SecureStorageOptions, type SecureStoreLike, type SecureStoreOptionsLike, type SyncQueryWithAppOptions, type UploadFromUriOptions, type UriUploadTarget, type WebBrowserLike, bindClient as createNativeClient, handleAuthDeepLink, linkParams, signInWithOAuthBrowser };
+export { type AesCryptoLike, type AppStateLike, type AsyncStorageLike, type AuthFailure, type AuthLinkClient, type AuthLinkResult, type AuthSnapshot, type AuthStorage, type AuthUser, type AutoRefreshClient, type BetterClient, type BindClientOptions, type ClientAuth, type ClientPorts, type DeepLinkPort, type DocumentPickerAsset, type DocumentPickerLike, type ExpoNotificationsLike, type ExpoPushTokenOptions, type FilePickerPort, type FocusManagerLike, type KeyValue, type KeyValueStoreLike, type KeyboardPort, type LargeSecureStorageOptions, type LinkingLike, type MmkvLike, type NativePortsOptions, type NetInfoLike, type OAuthClient, type OAuthSignInOptions, type OnlineManagerLike, type PersistQueryCacheOptions, type PickFilesOptions, type PickedFile, type PushTokenPort, type QueryPersister, type SecureStorageOptions, type SecureStoreLike, type SecureStoreOptionsLike, type Shortcut, type StoragePort, type SyncQueryWithAppOptions, type TopicHandle, type TopicPort, type TopicWatch, type UploadDestination, type UploadFromUriOptions, type UploadPort, type UriUploadTarget, type WebBrowserLike, bindClient as createNativeClient, expoPushToken, handleAuthDeepLink, linkParams, memoryStorage, signInWithOAuthBrowser, storageUpload };

package/dist/client/native/index.js

@@ -1,8 +1,9 @@
-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 dbError } from "../../errors-8i6tSICm.js";
+import { r as err, s as toDbError, t as AsyncResult } from "../../result-BlgnMB0H.js";
+import { i as toBase64, r as fromBase64 } from "../../base64-BmeCBgGo.js";
+import { n as storageUpload, r as bindClient, t as memoryStorage } from "../../ports-DGK3KTDH.js";
 import { n as linkParams, r as signInWithOAuthBrowser, t as handleAuthDeepLink } from "../../auth-link-DrDX9KOT.js";
+import { t as expoPushToken } from "../../push-token-D6REHMMw.js";
 //#region src/client/native/auto-refresh.ts
 /**
 * Refreshes the Supabase session only while the app is in the foreground,
@@ -51,6 +52,64 @@ function keyValue(store) {
 	};
 }
 //#endregion
+//#region src/client/native/ports.ts
+/** The storage port over AsyncStorage, MMKV or any async string store. */
+function nativeStorage(store) {
+	return keyValue(store);
+}
+/** The deep link port over `expo-linking`. */
+function nativeDeepLinks(linking) {
+	return {
+		initial: () => linking.getInitialURL(),
+		subscribe: (listener) => {
+			const subscription = linking.addEventListener("url", ({ url }) => {
+				listener(url);
+			});
+			return () => {
+				subscription.remove();
+			};
+		}
+	};
+}
+/**
+* The file picker port over `expo-document-picker`. Files are read through
+* `fetch`, which reads `file://` and `content://` URIs on React Native.
+*/
+function nativeFilePicker(picker, read = (uri) => fetch(uri)) {
+	return async (options = {}) => {
+		const picked = await picker.getDocumentAsync({
+			...options.accept ? { type: [...options.accept] } : {},
+			multiple: options.multiple ?? false,
+			copyToCacheDirectory: true
+		});
+		if (picked.canceled) return [];
+		return picked.assets.map((asset) => ({
+			name: asset.name,
+			type: asset.mimeType,
+			size: asset.size,
+			uri: asset.uri,
+			read: async () => (await read(asset.uri)).arrayBuffer()
+		}));
+	};
+}
+/**
+* The React Native ports, from the Expo modules the app installs. Pass the
+* result to `createNativeClient(betterSupabase, supabase, { ports })`.
+*
+* ```ts
+* const ports = nativePorts({ supabase, storage: AsyncStorage, linking: Linking, notifications: Notifications });
+* ```
+*/
+function nativePorts(options) {
+	return {
+		...options.storage ? { storage: nativeStorage(options.storage) } : {},
+		...options.linking ? { links: nativeDeepLinks(options.linking) } : {},
+		...options.notifications ? { push: expoPushToken(options.notifications, { projectId: options.projectId }) } : {},
+		...options.documentPicker ? { files: nativeFilePicker(options.documentPicker) } : {},
+		...options.supabase ? { upload: storageUpload(options.supabase) } : {}
+	};
+}
+//#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. */
@@ -320,7 +379,7 @@ const TYPES = {
 function contentTypeOf(uri) {
 	const path = uri.split(/[?#]/, 1)[0] ?? uri;
 	const dot = path.lastIndexOf(".");
-	if (dot === -1 || dot < path.lastIndexOf("/")) return void 0;
+	if (dot === -1 || dot < path.lastIndexOf("/")) return;
 	return TYPES[path.slice(dot + 1).toLowerCase()];
 }
 /**
@@ -358,4 +417,4 @@ 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 };
+export { autoRefreshOnForeground, contentTypeOf, bindClient as createNativeClient, expoPushToken, handleAuthDeepLink, keyValue, largeSecureStorage, linkParams, memoryStorage, nativeDeepLinks, nativeFilePicker, nativePorts, nativeStorage, persistQueryCache, secureStorage, signInWithOAuthBrowser, storageUpload, syncQueryWithApp, uploadFromUri };