better-supabase 0.2.0 → 0.3.0

package/dist/env-BEToab0I.js

@@ -1,204 +0,0 @@
-//#region src/env/index.ts
-const PREFIXES = [
-	"",
-	"NEXT_PUBLIC_",
-	"VITE_",
-	"PUBLIC_",
-	"EXPO_PUBLIC_",
-	"NUXT_PUBLIC_"
-];
-const ENV_VARIABLES = {
-	url: PREFIXES.map((prefix) => `${prefix}SUPABASE_URL`),
-	publishableKey: PREFIXES.flatMap((prefix) => [`${prefix}SUPABASE_PUBLISHABLE_KEY`, `${prefix}SUPABASE_PUBLISHABLE_DEFAULT_KEY`]),
-	secretKey: ["SUPABASE_SECRET_KEY"],
-	dbUrl: ["SUPABASE_DB_URL", "DATABASE_URL"],
-	jwksUrl: ["SUPABASE_JWKS_URL"],
-	readUrl: ["SUPABASE_READ_URL"]
-};
-const LOOPBACK = /^(localhost|127(?:\.\d{1,3}){3}|\[::1\])$/;
-const HOSTED = /^([a-z0-9]{20})\.supabase\.co$/;
-var EnvValidationError = class extends Error {
-	name = "EnvValidationError";
-	issues;
-	constructor(issues) {
-		super(`Invalid Supabase environment:\n${issues.map((issue) => `  - ${issue.variables[0] ?? "env"}: ${issue.message}`).join("\n")}`);
-		this.issues = issues;
-	}
-};
-function first(source, names) {
-	for (const name of names) {
-		const value = source[name]?.trim();
-		if (value) return value;
-	}
-}
-/** `SUPABASE_*_KEYS` JSON objects, as `@supabase/server` reads them. */
-function keySet(source, name, kind, issues) {
-	const raw = source[name];
-	if (!raw) return void 0;
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch {
-		parsed = void 0;
-	}
-	const entries = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? Object.entries(parsed) : [];
-	if (entries.length === 0 || entries.some(([, value]) => typeof value !== "string")) {
-		issues.push({
-			variables: [name],
-			message: "must be a JSON object of key names to keys"
-		});
-		return;
-	}
-	const keys = {};
-	for (const [key, value] of entries) if (checkKey(value, kind, [name], issues)) keys[key] = value;
-	return keys;
-}
-function preferred(keys) {
-	if (!keys) return void 0;
-	return keys["default"] ?? Object.values(keys)[0];
-}
-function checkUrl(value, variables, issues) {
-	let url;
-	try {
-		url = new URL(value);
-	} catch {
-		issues.push({
-			variables,
-			message: "is not a valid URL"
-		});
-		return;
-	}
-	if (url.protocol === "https:") return url;
-	if (url.protocol === "http:" && LOOPBACK.test(url.hostname)) return url;
-	issues.push({
-		variables,
-		message: "must use https (http is only allowed for localhost / 127.0.0.1 / [::1])"
-	});
-}
-function checkKey(value, kind, variables, issues) {
-	if (value.startsWith(`sb_${kind}_`)) return true;
-	if (value.startsWith("eyJ")) issues.push({
-		variables,
-		message: `is a legacy JWT key; use the new sb_${kind}_ key (Project Settings > API Keys)`
-	});
-	else if (value.startsWith(kind === "publishable" ? "sb_secret_" : "sb_publishable_")) issues.push({
-		variables,
-		message: kind === "publishable" ? "holds a secret key; never expose sb_secret_ keys as publishable" : "holds a publishable key, not a secret key"
-	});
-	else issues.push({
-		variables,
-		message: `must start with sb_${kind}_`
-	});
-	return false;
-}
-/**
-* Reads and validates Supabase settings. Accepts the `SUPABASE_`,
-* `NEXT_PUBLIC_`, `VITE_`, `PUBLIC_`, `EXPO_PUBLIC_` and `NUXT_PUBLIC_`
-* spellings. Issues name variables, never values.
-*/
-function parseEnv(source, options = {}) {
-	const issues = [];
-	const required = new Set(options.require ?? []);
-	const rawUrl = first(source, ENV_VARIABLES.url);
-	const url = rawUrl ? checkUrl(rawUrl, ENV_VARIABLES.url, issues) : void 0;
-	if (!rawUrl) issues.push({
-		variables: ENV_VARIABLES.url,
-		message: "is not set"
-	});
-	const publishableKeys = keySet(source, "SUPABASE_PUBLISHABLE_KEYS", "publishable", issues);
-	const singlePublishable = first(source, ENV_VARIABLES.publishableKey);
-	const publishableKey = singlePublishable ?? preferred(publishableKeys);
-	if (!publishableKey) issues.push({
-		variables: ENV_VARIABLES.publishableKey,
-		message: "is not set"
-	});
-	else if (singlePublishable) checkKey(publishableKey, "publishable", ENV_VARIABLES.publishableKey, issues);
-	const namedSecrets = keySet(source, "SUPABASE_SECRET_KEYS", "secret", issues);
-	const singleSecret = first(source, ENV_VARIABLES.secretKey);
-	const secretKey = singleSecret ?? preferred(namedSecrets);
-	if (singleSecret) checkKey(singleSecret, "secret", ENV_VARIABLES.secretKey, issues);
-	else if (!secretKey && required.has("secretKey")) issues.push({
-		variables: ENV_VARIABLES.secretKey,
-		message: "is not set"
-	});
-	const dbUrl = first(source, ENV_VARIABLES.dbUrl);
-	if (dbUrl && !/^postgres(ql)?:\/\//.test(dbUrl)) issues.push({
-		variables: ENV_VARIABLES.dbUrl,
-		message: "must be a postgres:// connection string"
-	});
-	else if (!dbUrl && required.has("dbUrl")) issues.push({
-		variables: ENV_VARIABLES.dbUrl,
-		message: "is not set"
-	});
-	const rawJwks = first(source, ENV_VARIABLES.jwksUrl);
-	const jwksOverride = rawJwks ? checkUrl(rawJwks, ENV_VARIABLES.jwksUrl, issues) : void 0;
-	const rawRead = first(source, ENV_VARIABLES.readUrl);
-	const readUrl = rawRead ? checkUrl(rawRead, ENV_VARIABLES.readUrl, issues) : void 0;
-	if (issues.length > 0 || !url || !publishableKey) return {
-		ok: false,
-		issues
-	};
-	const base = url.href.replace(/\/+$/, "");
-	const projectRef = HOSTED.exec(url.hostname)?.[1];
-	return {
-		ok: true,
-		env: {
-			url: base,
-			publishableKey,
-			jwksUrl: jwksOverride ?? new URL(`${base}/auth/v1/.well-known/jwks.json`),
-			...secretKey ? {
-				secretKey,
-				secretKeys: {
-					...namedSecrets,
-					default: secretKey
-				}
-			} : {},
-			...dbUrl ? { dbUrl } : {},
-			...projectRef ? { projectRef } : {},
-			...readUrl ? { readUrl: readUrl.href.replace(/\/+$/, "") } : {}
-		}
-	};
-}
-function processEnv() {
-	return globalThis.process?.env ?? {};
-}
-/** Like `parseEnv`, but throws `EnvValidationError`. Reads `process.env` by default. */
-function loadEnv(source = processEnv(), options = {}) {
-	const result = parseEnv(source, options);
-	if (!result.ok) throw new EnvValidationError(result.issues);
-	return result.env;
-}
-/** The env validator as a Standard Schema, for t3-env, framework config or any validator slot. */
-function envSchema(options = {}) {
-	return { "~standard": {
-		version: 1,
-		vendor: "better-supabase",
-		validate(value) {
-			if (typeof value !== "object" || value === null) return { issues: [{ message: "Expected an environment object" }] };
-			const result = parseEnv(value, options);
-			if (result.ok) return { value: result.env };
-			return { issues: result.issues.map((issue) => ({
-				message: `${issue.variables[0] ?? "env"} ${issue.message}`,
-				path: issue.variables.slice(0, 1)
-			})) };
-		}
-	} };
-}
-/** The parts that are safe in client bundles. */
-function publicEnv(env) {
-	return {
-		url: env.url,
-		publishableKey: env.publishableKey
-	};
-}
-/** Converts to `@supabase/server`'s `SupabaseEnv` (the `env` option of `withSupabase`). */
-function toServerEnv(env) {
-	return {
-		url: env.url,
-		publishableKeys: { default: env.publishableKey },
-		secretKeys: env.secretKeys ?? (env.secretKey ? { default: env.secretKey } : {}),
-		jwks: env.jwksUrl
-	};
-}
-//#endregion
-export { parseEnv as a, loadEnv as i, EnvValidationError as n, publicEnv as o, envSchema as r, toServerEnv as s, ENV_VARIABLES as t };

package/dist/events-BuzTgn2D.js

@@ -1,135 +0,0 @@
-//#region src/events/index.ts
-const ROW_EVENT_TYPES = {
-	insert: "dev.better-supabase.row.created",
-	upsert: "dev.better-supabase.row.upserted",
-	update: "dev.better-supabase.row.updated",
-	delete: "dev.better-supabase.row.deleted"
-};
-function subjectOf(meta, table, row) {
-	const key = meta?.tables[table]?.primaryKey;
-	if (!key || key.length === 0) return void 0;
-	const values = key.map((column) => row[column]);
-	if (values.some((value) => value === void 0 || value === null)) return void 0;
-	return `${table}/${values.map((value) => encodeURIComponent(String(value))).join(",")}`;
-}
-/**
-* One CloudEvent per mutated row: `dev.better-supabase.row.created` with the
-* app-cased row as `data`, the primary key as `subject`, the tenant as
-* `partitionkey` and the actor as `actorid`.
-*/
-function toCloudEvents(notice, options) {
-	const type = options.typePrefix ? `${options.typePrefix}.row.${ROW_EVENT_TYPES[notice.kind].split(".").at(-1)}` : ROW_EVENT_TYPES[notice.kind];
-	const time = (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
-	return notice.rows.map((row) => {
-		const subject = subjectOf(options.meta, notice.table, row);
-		return {
-			specversion: "1.0",
-			id: options.id?.() ?? crypto.randomUUID(),
-			source: options.source,
-			type,
-			...subject ? { subject } : {},
-			time,
-			datacontenttype: "application/json",
-			data: {
-				table: notice.table,
-				row
-			},
-			...notice.context.tenant ? { partitionkey: notice.context.tenant } : {},
-			...notice.context.actor?.id ? { actorid: notice.context.actor.id } : {}
-		};
-	});
-}
-/**
-* Sends a CloudEvent for every mutation to `sink`. Returns a function that
-* stops forwarding. Use an outbox (SQL kit) when events must not be lost.
-*/
-function forwardMutations(sb, sink, options) {
-	return sb.events.on("mutation", (notice) => {
-		if (options.filter && !options.filter(notice)) return;
-		const events = toCloudEvents(notice, {
-			...options,
-			meta: sb.meta
-		});
-		if (events.length === 0) return;
-		const report = (error) => (options.onError ?? ((cause) => sb.events.logger.error("event sink failed", { cause })))(error, events);
-		try {
-			Promise.resolve(sink.send(events)).catch(report);
-		} catch (error) {
-			report(error);
-		}
-	});
-}
-const STRUCTURED = "application/cloudevents+json";
-const BATCH = "application/cloudevents-batch+json";
-/** The HTTP protocol binding: headers and body for one event (or a batch). */
-function toHttp(events, mode = "structured") {
-	const list = Array.isArray(events) ? events : [events];
-	switch (mode) {
-		case "batch": return [{
-			headers: { "content-type": BATCH },
-			body: JSON.stringify(list)
-		}];
-		case "structured": return list.map((event) => ({
-			headers: { "content-type": STRUCTURED },
-			body: JSON.stringify(event)
-		}));
-		case "binary": return list.map((event) => {
-			const headers = {};
-			for (const [key, value] of Object.entries(event)) {
-				if (key === "data" || key === "datacontenttype" || value === void 0) continue;
-				headers[`ce-${key}`] = encodeURIComponent(String(value)).replace(/%20/g, " ");
-			}
-			headers["content-type"] = event.datacontenttype ?? "application/json";
-			return {
-				headers,
-				body: event.data === void 0 ? "" : JSON.stringify(event.data)
-			};
-		});
-		default: throw new TypeError(`Unknown CloudEvents mode ${String(mode)}`);
-	}
-}
-function isCloudEvent(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const event = value;
-	return event["specversion"] === "1.0" && typeof event["id"] === "string" && typeof event["source"] === "string" && typeof event["type"] === "string";
-}
-/** Reads CloudEvents from a request in any of the three HTTP modes. */
-async function fromHttp(request) {
-	const contentType = request.headers.get("content-type") ?? "";
-	const text = await request.text();
-	if (contentType.startsWith(BATCH)) {
-		const parsed = JSON.parse(text);
-		if (!Array.isArray(parsed) || !parsed.every(isCloudEvent)) throw new TypeError("Invalid CloudEvents batch");
-		return parsed;
-	}
-	if (contentType.startsWith(STRUCTURED)) {
-		const parsed = JSON.parse(text);
-		if (!isCloudEvent(parsed)) throw new TypeError("Invalid CloudEvent");
-		return [parsed];
-	}
-	const event = {};
-	for (const [key, value] of request.headers) if (key.startsWith("ce-")) event[key.slice(3)] = decodeURIComponent(value);
-	if (contentType) event["datacontenttype"] = contentType;
-	if (text) event["data"] = /json/.test(contentType) ? JSON.parse(text) : text;
-	if (!isCloudEvent(event)) throw new TypeError("Request is not a CloudEvent");
-	return [event];
-}
-/** POSTs events to `url`. Non-2xx responses reject. */
-function httpSink(url, options = {}) {
-	const send = options.fetch ?? fetch;
-	return { async send(events) {
-		for (const message of toHttp(events, options.mode ?? "batch")) {
-			const response = await send(url, {
-				method: "POST",
-				headers: {
-					...options.headers,
-					...message.headers
-				},
-				body: message.body
-			});
-			if (!response.ok) throw new Error(`Event sink responded ${String(response.status)}`);
-		}
-	} };
-}
-//#endregion
-export { isCloudEvent as a, httpSink as i, forwardMutations as n, toCloudEvents as o, fromHttp as r, toHttp as s, ROW_EVENT_TYPES as t };

package/dist/pool-R2m_DkXi.d.ts

@@ -1,37 +0,0 @@
-import { t as SqlClient } from "./executor-BYXQ9AGn.js";
-//#region src/postgres/pool.d.ts
-interface PostgresOptions {
-  /** Defaults to `$SUPABASE_DB_URL`, then `$DATABASE_URL`. */
-  readonly connectionString?: string;
-  readonly max?: number;
-  /** Statement timeout in milliseconds, applied per transaction. */
-  readonly statementTimeout?: number;
-}
-/** JWT claims to run as. `role` must be `authenticated` or `anon`. */
-interface SqlClaims {
-  readonly sub?: string;
-  readonly role?: string;
-  readonly [claim: string]: unknown;
-}
-interface Postgres {
-  /** Connects as the connection-string role. On Supabase that bypasses RLS. */
-  readonly admin: SqlClient;
-  /** Runs every query as the given user, with RLS, like PostgREST does. */
-  asUser(claims: SqlClaims): SqlClient;
-  /** Runs every query as `anon`. */
-  readonly anon: SqlClient;
-  /** Runs `fn` in one transaction. Pass claims to run it as a user. */
-  transaction<T>(fn: (client: SqlClient) => Promise<T>, options?: {
-    readonly claims?: SqlClaims;
-  }): Promise<T>;
-  end(): Promise<void>;
-  [Symbol.asyncDispose](): Promise<void>;
-}
-/**
- * A pooled Postgres connection for jobs, scripts and tests. Each query (or
- * transaction) runs in its own transaction; claims and role are
- * transaction-local, so nothing leaks back into the pool.
- */
-declare function createPostgres(options?: PostgresOptions): Postgres;
-//#endregion
-export { createPostgres as i, PostgresOptions as n, SqlClaims as r, Postgres as t };

package/dist/seed-CzecODcJ.js

@@ -1,101 +0,0 @@
-//#region src/testing/seed.ts
-const SEED = Symbol.for("better-supabase.seed");
-function isSeed(value) {
-	return typeof value === "object" && value !== null && SEED in value;
-}
-const quote = (text) => `'${text.replaceAll("'", "''")}'`;
-function arrayLiteral(values) {
-	return `{${values.map((value) => {
-		if (value === null) return "NULL";
-		if (Array.isArray(value)) return arrayLiteral(value);
-		return `"${(value instanceof Date ? value.toISOString() : String(value)).replace(/[\\"]/g, "\\$&")}"`;
-	}).join(",")}}`;
-}
-function literal(value, column, where) {
-	if (value === null) return "null";
-	if (column.json) return quote(JSON.stringify(value));
-	if (Array.isArray(value)) return quote(arrayLiteral(value));
-	if (value instanceof Date) return quote(value.toISOString());
-	const kind = typeof value;
-	switch (kind) {
-		case "string": return quote(value);
-		case "boolean":
-		case "bigint": return String(value);
-		case "number":
-			if (!Number.isFinite(value)) throw new TypeError(`${where}: ${String(value)} is not a finite number`);
-			return String(value);
-		case "object":
-		case "function":
-		case "symbol":
-		case "undefined": throw new TypeError(`${where}: unsupported value of type ${kind}`);
-		default: throw new TypeError(`${where}: unsupported value of type ${String(kind)}`);
-	}
-}
-const ident = (name) => `"${name.replaceAll("\"", "\"\"")}"`;
-/** Parents first (by forward relations), otherwise in the order given. */
-function order(meta, keys) {
-	const sorted = [];
-	const visiting = /* @__PURE__ */ new Set();
-	const visit = (key) => {
-		if (sorted.includes(key) || visiting.has(key)) return;
-		visiting.add(key);
-		for (const relation of Object.values(meta.tables[key]?.relations ?? {})) if (relation.direction === "forward" && relation.table !== key && keys.includes(relation.table)) visit(relation.table);
-		visiting.delete(key);
-		sorted.push(key);
-	};
-	for (const key of keys) visit(key);
-	return sorted;
-}
-function statement(table, rows) {
-	const entries = Object.entries(rows);
-	if (entries.length === 0) return void 0;
-	const columns = [];
-	for (const [, row] of entries) for (const [key, value] of Object.entries(row)) {
-		if (value === void 0 || columns.includes(key)) continue;
-		const column = table.columns[key];
-		if (!column) throw new TypeError(`seed ${table.key}: unknown column "${key}"`);
-		if (column.generated) throw new TypeError(`seed ${table.key}: "${key}" is a generated column`);
-		columns.push(key);
-	}
-	const values = entries.map(([name, row]) => {
-		return `  (${columns.map((key) => row[key] === void 0 ? "default" : literal(row[key], table.columns[key], `seed ${table.key}.${name}.${key}`)).join(", ")})`;
-	});
-	return `insert into ${`${ident(table.schema)}.${ident(table.name)}`} (${columns.map((key) => ident(table.columns[key].db)).join(", ")}) values\n${values.join(",\n")}\non conflict do nothing;`;
-}
-/**
-* Typed fixtures shared by `supabase/seeds` and your tests. Rows use app
-* casing and Insert types; `better-supabase seed` renders them to SQL.
-*
-* ```ts
-* export const seed = defineSeed(sb, {
-*   organizations: { acme: { id: ACME, name: 'Acme' } },
-*   customers: { first: { organizationId: ACME, name: 'First customer' } },
-* });
-* ```
-*/
-function defineSeed(sb, fixtures) {
-	const meta = sb.meta;
-	const statements = () => {
-		const keys = Object.keys(fixtures).filter((key) => fixtures[key] !== void 0);
-		for (const key of keys) {
-			const table = meta.tables[key];
-			if (!table) throw new TypeError(`seed: unknown table "${key}"`);
-			if (table.kind === "view") throw new TypeError(`seed: "${key}" is a view`);
-		}
-		return order(meta, keys).flatMap((key) => {
-			const sql = statement(meta.tables[key], fixtures[key]);
-			return sql ? [sql] : [];
-		});
-	};
-	return {
-		[SEED]: true,
-		rows: fixtures,
-		statements,
-		sql: () => statements().join("\n\n"),
-		async insert(sql) {
-			for (const text of statements()) await sql.queryRaw(text);
-		}
-	};
-}
-//#endregion
-export { isSeed as n, defineSeed as t };

package/dist/session-C3LxnQ0e.d.ts

@@ -1,22 +0,0 @@
-import { t as AuthSession } from "./view-D1s0wa0T.js";
-import { ReactNode } from "react";
-//#region src/react/session.d.ts
-interface SessionProviderProps {
-  /**
-   * An unresolved `next.session()` promise, created inside a `<Suspense>`
-   * boundary so the layout itself never waits for auth.
-   */
-  readonly sessionPromise: Promise<AuthSession>;
-  readonly children?: ReactNode;
-}
-/** Shares the server-verified session with Client Components. */
-declare function SessionProvider(props: SessionProviderProps): ReactNode;
-/**
- * The session from the nearest `<SessionProvider>`. Suspends until the
- * promise resolves, so render it inside `<Suspense>`. `C` types the claims
- * (the output of `sb.claims(schema)`) and `P` the profile (the output of
- * `sb.userMetadata(schema)`); `createHooks().useSession` infers both.
- */
-declare function useSession<C = unknown, P = unknown>(): AuthSession<C, P>;
-//#endregion
-export { SessionProviderProps as n, useSession as r, SessionProvider as t };

package/dist/session-CqEwzVup.js

@@ -1,20 +0,0 @@
-import { createContext, createElement, use, useContext } from "react";
-//#region src/react/session.ts
-const SessionContext = createContext(null);
-/** Shares the server-verified session with Client Components. */
-function SessionProvider(props) {
-	return createElement(SessionContext.Provider, { value: props.sessionPromise }, props.children);
-}
-/**
-* The session from the nearest `<SessionProvider>`. Suspends until the
-* promise resolves, so render it inside `<Suspense>`. `C` types the claims
-* (the output of `sb.claims(schema)`) and `P` the profile (the output of
-* `sb.userMetadata(schema)`); `createHooks().useSession` infers both.
-*/
-function useSession() {
-	const promise = useContext(SessionContext);
-	if (!promise) throw new Error("better-supabase: useSession() needs <SessionProvider sessionPromise={...}>");
-	return use(promise);
-}
-//#endregion
-export { useSession as n, SessionProvider as t };