better-supabase 0.5.0 → 0.6.0

package/dist/cli/typegen-version-DeFbtzYI.js

@@ -0,0 +1,8 @@
+//#region src/cli/introspect/typegen-version.ts
+/**
+* The `@supabase/postgrest-typegen` version `database.types.ts` output is
+* pinned to. The peer range is this exact version; a test checks the catalog.
+*/
+const TYPEGEN_VERSION = "0.4.0";
+//#endregion
+export { TYPEGEN_VERSION as t };

package/dist/cli/{version-BDJuO0UR.js → version-hr88OZG0.js}

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

package/dist/client/index.d.ts

@@ -1,2 +1,3 @@
-import { a as ClientOptions, i as ClientAuth, n as AuthUser, o as createClient, r as BetterClient, t as AuthSnapshot } from "../index-DmXSxbLi.js";
-export { AuthSnapshot, AuthUser, BetterClient, ClientAuth, ClientOptions, createClient };
+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 };

package/dist/client/index.js

@@ -1,45 +1,8 @@
-import { n as decodeJwtPayload } from "../base64-D2gsioCY.js";
-import { r as userContext } from "../impersonation-VfaGc4Q_.js";
 import { EnvValidationError, parseEnv } from "../env/index.js";
-import { t as createQueries } from "../query-CCbo44lG.js";
+import { t as bindClient } from "../bind-l4kAvYSv.js";
 import { createBrowserClient } from "@supabase/ssr";
 import { createClient as createClient$1 } from "@supabase/supabase-js";
 //#region src/client/index.ts
-const LOADING = {
-	status: "loading",
-	user: null,
-	claims: null
-};
-const SIGNED_OUT = {
-	status: "signed-out",
-	user: null,
-	claims: null
-};
-function snapshotOf(session) {
-	if (!session) return SIGNED_OUT;
-	const claims = decodeJwtPayload(session.access_token) ?? {};
-	const role = typeof claims["role"] === "string" ? claims["role"] : session.user.role;
-	return {
-		status: "signed-in",
-		user: {
-			id: session.user.id,
-			...session.user.email ? { email: session.user.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);
-}
 function clientFor(options) {
 	if (options.client) return options.client;
 	if (!options.env) throw new TypeError("createClient needs `env` ({ url, publishableKey }) or `client`");
@@ -48,8 +11,14 @@ function clientFor(options) {
 		SUPABASE_PUBLISHABLE_KEY: options.env.publishableKey
 	});
 	if (!checked.ok) throw new EnvValidationError(checked.issues);
-	if (options.storage === "local") return createClient$1(checked.env.url, checked.env.publishableKey);
-	return createBrowserClient(checked.env.url, checked.env.publishableKey);
+	const userStorage = options.auth?.userStorage;
+	const auth = userStorage ? { auth: { userStorage } } : {};
+	if (options.storage === "local") return createClient$1(checked.env.url, checked.env.publishableKey, auth);
+	const encode = options.cookies?.encode;
+	return createBrowserClient(checked.env.url, checked.env.publishableKey, {
+		...auth,
+		...encode ? { cookies: { encode } } : {}
+	});
 }
 /**
 * The browser side: a supabase-js client, repositories that follow the
@@ -60,36 +29,7 @@ function clientFor(options) {
 * ```
 */
 function createClient(betterSupabase, options = {}) {
-	const supabase = clientFor(options);
-	let snapshot = LOADING;
-	let db;
-	const listeners = /* @__PURE__ */ new Set();
-	supabase.auth.onAuthStateChange((_event, session) => {
-		const next = snapshotOf(session);
-		if (!(next.status !== snapshot.status || next.user?.id !== snapshot.user?.id || next.status === "signed-in" && snapshot.status === "signed-in" && next.claims["exp"] !== snapshot.claims["exp"])) 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),
-		auth: {
-			current: () => snapshot,
-			subscribe: (listener) => {
-				listeners.add(listener);
-				return () => {
-					listeners.delete(listener);
-				};
-			}
-		}
-	};
-	return client;
+	return bindClient(betterSupabase, clientFor(options), options.staleTime === void 0 ? {} : { staleTime: options.staleTime });
 }
 //#endregion
-export { createClient };
+export { bindClient, createClient };

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

@@ -0,0 +1,228 @@
+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 { 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";
+//#region src/client/native/auto-refresh.d.ts
+/** The part of React Native's `AppState` that `autoRefreshOnForeground` uses. */
+interface AppStateLike {
+  readonly currentState: string;
+  addEventListener(type: "change", listener: (state: string) => void): {
+    remove(): void;
+  };
+}
+/** The part of a supabase-js client that `autoRefreshOnForeground` uses. */
+interface AutoRefreshClient {
+  readonly auth: {
+    startAutoRefresh(): Promise<void>;
+    stopAutoRefresh(): Promise<void>;
+  };
+}
+/**
+ * Refreshes the Supabase session only while the app is in the foreground,
+ * as supabase-js requires on React Native. Returns a function that removes
+ * the listener and stops refreshing.
+ *
+ * ```ts
+ * import { AppState } from 'react-native';
+ * autoRefreshOnForeground(supabase, AppState);
+ * ```
+ */
+export declare function autoRefreshOnForeground(supabase: AutoRefreshClient, appState: AppStateLike): () => void;
+//#endregion
+//#region src/client/native/key-value.d.ts
+/** `@react-native-async-storage/async-storage` or any async string store. */
+interface AsyncStorageLike {
+  getItem(key: string): Promise<string | null>;
+  setItem(key: string, value: string): Promise<void>;
+  removeItem(key: string): Promise<void>;
+}
+/** `react-native-mmkv`: `delete` up to v3, `remove` from v4. */
+interface MmkvLike {
+  getString(key: string): string | undefined;
+  set(key: string, value: string): void;
+  delete?(key: string): void;
+  remove?(key: string): unknown;
+}
+type KeyValueStoreLike = AsyncStorageLike | MmkvLike;
+/** A store with async `get`, `set` and `remove`, whichever kind it wraps. */
+interface KeyValue {
+  get(key: string): Promise<string | null>;
+  set(key: string, value: string): Promise<void>;
+  remove(key: string): Promise<void>;
+}
+export declare function keyValue(store: KeyValueStoreLike): KeyValue;
+//#endregion
+//#region src/client/native/storage.d.ts
+/** The part of `expo-secure-store` the storage adapter uses. */
+interface SecureStoreLike {
+  getItemAsync(key: string, options?: SecureStoreOptionsLike): Promise<string | null>;
+  setItemAsync(key: string, value: string, options?: SecureStoreOptionsLike): Promise<void>;
+  deleteItemAsync(key: string, options?: SecureStoreOptionsLike): Promise<void>;
+}
+/**
+ * The `expo-secure-store` options every call gets, such as
+ * `keychainAccessible` or `keychainService`.
+ */
+interface SecureStoreOptionsLike {
+  /**
+   * When the keychain item is readable. `SecureStore.AFTER_FIRST_UNLOCK`
+   * lets a background task or a push handler refresh the session while the
+   * device is locked; the default (`WHEN_UNLOCKED`) does not.
+   */
+  readonly keychainAccessible?: number;
+  readonly keychainService?: string;
+  readonly requireAuthentication?: boolean;
+  readonly [option: string]: unknown;
+}
+/** The storage interface supabase-js `auth.storage` takes. */
+interface AuthStorage {
+  getItem(key: string): Promise<string | null>;
+  setItem(key: string, value: string): Promise<void>;
+  removeItem(key: string): Promise<void>;
+}
+interface SecureStorageOptions {
+  /**
+   * Characters per stored value. Defaults to 1800: iOS warns above 2048
+   * bytes, and a Supabase session with custom claims is larger than that.
+   */
+  readonly chunkSize?: number;
+  /** Passed to every `expo-secure-store` call. */
+  readonly storeOptions?: SecureStoreOptionsLike;
+}
+/**
+ * Supabase Auth storage on the device keychain (`expo-secure-store`),
+ * split into chunks so sessions above the platform's value size fit.
+ * Operations on one key run one at a time, and a write moves the pointer
+ * only after every chunk is stored, so a reader never joins chunks of two
+ * values and a write that fails part way keeps the previous value.
+ *
+ * ```ts
+ * import * as SecureStore from 'expo-secure-store';
+ * createClient(url, key, { auth: { storage: secureStorage(SecureStore) } });
+ * ```
+ */
+export declare function secureStorage(store: SecureStoreLike, options?: SecureStorageOptions): AuthStorage;
+//#endregion
+//#region src/client/native/large-storage.d.ts
+/** WebCrypto with AES-GCM: the global `crypto`, or `react-native-quick-crypto`. */
+interface AesCryptoLike {
+  getRandomValues<T extends Uint8Array<ArrayBuffer>>(array: T): T;
+  readonly subtle: Pick<SubtleCrypto, "importKey" | "encrypt" | "decrypt">;
+}
+interface LargeSecureStorageOptions {
+  /** Holds the 256-bit key per session key: `expo-secure-store`. */
+  readonly secureStore: SecureStoreLike;
+  /** Holds the encrypted session: MMKV or AsyncStorage. */
+  readonly storage: KeyValueStoreLike;
+  /** Defaults to the global `crypto`; Hermes needs `react-native-quick-crypto`. */
+  readonly crypto?: AesCryptoLike;
+  /** Passed to every `expo-secure-store` call. */
+  readonly storeOptions?: SecureStoreOptionsLike;
+}
+/**
+ * Supabase Auth storage for sessions of any size: the session is encrypted
+ * with AES-GCM and kept in MMKV or AsyncStorage, and only its key lives in
+ * the keychain. A key that no longer decrypts (the app was reinstalled and
+ * one store kept its data) reads as signed out and is replaced on the next
+ * sign-in.
+ *
+ * ```ts
+ * import * as SecureStore from 'expo-secure-store';
+ * import AsyncStorage from '@react-native-async-storage/async-storage';
+ * createClient(url, key, { auth: { storage: largeSecureStorage({ secureStore: SecureStore, storage: AsyncStorage }) } });
+ * ```
+ */
+export declare function largeSecureStorage(options: LargeSecureStorageOptions): AuthStorage;
+//#endregion
+//#region src/client/native/persist.d.ts
+/**
+ * TanStack Query's `Persister`: pass it as `persistOptions.persister` to
+ * `PersistQueryClientProvider` or `persistQueryClient`.
+ */
+interface QueryPersister<T> {
+  persistClient(client: T): Promise<void>;
+  restoreClient(): Promise<T | undefined>;
+  removeClient(): Promise<void>;
+}
+interface PersistQueryCacheOptions {
+  /** Defaults to `better-supabase.query-cache`. */
+  readonly key?: string;
+  /** Writes at most once per interval, keeping the latest cache. Defaults to 1000 ms. */
+  readonly throttleMs?: number;
+}
+/**
+ * Persists the query cache to MMKV or AsyncStorage, so a cold start shows
+ * the last rows before the first fetch. The provider's `clearOnUserChange`
+ * drops them when another user signs in.
+ *
+ * ```tsx
+ * <PersistQueryClientProvider client={queryClient} persistOptions={{ persister: persistQueryCache(storage) }}>
+ * ```
+ */
+export declare function persistQueryCache<T>(storage: KeyValueStoreLike, options?: PersistQueryCacheOptions): QueryPersister<T>;
+//#endregion
+//#region src/client/native/query.d.ts
+/** The part of TanStack Query's `focusManager` that `syncQueryWithApp` uses. */
+interface FocusManagerLike {
+  setEventListener(setup: (setFocused: (focused?: boolean) => void) => (() => void) | undefined): void;
+}
+/** The part of TanStack Query's `onlineManager` that `syncQueryWithApp` uses. */
+interface OnlineManagerLike {
+  setEventListener(setup: (setOnline: (online: boolean) => void) => (() => void) | undefined): void;
+}
+/** The part of `@react-native-community/netinfo` that `syncQueryWithApp` uses. */
+interface NetInfoLike {
+  addEventListener(listener: (state: {
+    readonly isConnected: boolean | null;
+    readonly isInternetReachable?: boolean | null;
+  }) => void): () => void;
+}
+interface SyncQueryWithAppOptions {
+  readonly focusManager: FocusManagerLike;
+  readonly appState: AppStateLike;
+  /** With `netInfo`, queries pause offline and refetch on reconnect. */
+  readonly onlineManager?: OnlineManagerLike;
+  readonly netInfo?: NetInfoLike;
+  /** Also refresh the session only in the foreground (`autoRefreshOnForeground`). */
+  readonly supabase?: AutoRefreshClient;
+}
+/**
+ * Wires TanStack Query to the app lifecycle on React Native: queries count
+ * as focused while the app is active, and as online while NetInfo reports
+ * a connection (an unreachable internet counts as offline). Returns a
+ * function that removes every listener.
+ *
+ * ```ts
+ * import { focusManager, onlineManager } from '@tanstack/react-query';
+ * import NetInfo from '@react-native-community/netinfo';
+ * import { AppState } from 'react-native';
+ * syncQueryWithApp({ focusManager, onlineManager, appState: AppState, netInfo: NetInfo, supabase });
+ * ```
+ */
+export declare function syncQueryWithApp(options: SyncQueryWithAppOptions): () => void;
+//#endregion
+//#region src/client/native/upload.d.ts
+/** The part of a connected bucket `uploadFromUri` calls. */
+interface UriUploadTarget<T, R> {
+  upload(target: T, body: UploadBody, options?: UploadOptions): AsyncResult<R>;
+}
+interface UploadFromUriOptions extends UploadOptions {
+  /** Defaults to the global `fetch`, which reads `file://` and `content://` URIs on React Native. */
+  readonly fetch?: (uri: string) => Promise<Response>;
+}
+/** The content type for a file URI's extension, ignoring a query or fragment. */
+export declare function contentTypeOf(uri: string): string | undefined;
+/**
+ * Uploads a local file (an `expo-image-picker` or `expo-document-picker`
+ * URI) to a connected bucket. The file is read into an `ArrayBuffer`, as
+ * React Native's `Blob` can't be uploaded; the content type comes from the
+ * option, the response or the extension.
+ *
+ * ```ts
+ * const picked = await ImagePicker.launchImageLibraryAsync();
+ * await uploadFromUri(avatars, { userId }, picked.assets[0].uri, { upsert: true });
+ * ```
+ */
+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 };