better-supabase 0.0.0 → 0.2.0

package/dist/server/index.d.ts

@@ -0,0 +1,42 @@
+import { n as AnyModels, t as AnyFunctions } from "../types-C83v5SQz.js";
+import { t as BetterSupabase, y as Db } from "../define-e3zI4_4g.js";
+import { h as RequestContext } from "../plugin-C4TR9J0Z.js";
+import { a as checkAal, c as impersonatorOf, i as amrOf, n as AmrEntry, o as ImpersonationOptions, r as aalOf, s as Impersonator, t as Aal } from "../mfa-TVia554c.js";
+import { _ as readSession, a as ResolveAuthOptions, b as writeSession, c as clientIp, d as CookieOptions, f as CookieRecord, i as InvalidReason, l as resolveAuth, m as StoredSession, n as AuthResolver, o as ResolvedState, p as CookieWrite, r as AuthState, s as authContext, t as AuthResolution, u as AUTH_CACHE_HEADERS, y as sessionCookieName } from "../resolve-CjHILk2w.js";
+import { _ as DeleteAccountResult, a as guard, c as settle, d as ServerContext, f as ServerOptions, g as DeleteAccountOptions, h as ReplicaState, i as Settled, l as BetterServer, m as PRIMARY_COOKIE, n as GuardOptions, o as isResult, p as createServer, r as RespondOptions, s as respond, t as AuthKind, u as ContextOptions } from "../respond-Dne1ARSa.js";
+import { a as defineResource, i as ResourceRouteOptions, n as ResourceInput, r as ResourceList, t as ResourceHandler } from "../resource-CgZa3YG_.js";
+import { a as ProblemResponseOptions, c as problemResponse, i as ProblemOptions, l as toProblem, n as PROBLEM_TYPE_BASE, o as fromProblem, r as ProblemDetails, s as isProblem, t as PROBLEM_CONTENT_TYPE } from "../problem-DlgB0lYl.js";
+import { n as RefreshOutcome, r as refreshSession } from "../index-CG69s15v.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Middleware } from "@supabase/middleware";
+import { AuthMode, JWTClaims, UserClaims } from "@supabase/server";
+import { PostgresApi } from "@supabase/server/middleware/postgres";
+//#region src/server/middleware.d.ts
+/** The `withSupabase` context keys `withBetterSupabase` reads. */
+interface SupabaseAuthContext {
+  readonly jwtClaims: JWTClaims | null;
+  readonly userClaims: UserClaims | null;
+  readonly authMode: AuthMode;
+}
+/** Repository context from a `@supabase/server` context. */
+export declare function contextFromSupabase(ctx: SupabaseAuthContext): RequestContext;
+/**
+ * `@supabase/middleware` entry contributing `ctx.db`: repositories bound to
+ * `ctx.supabase` (the caller-scoped client from `withSupabase`).
+ *
+ * ```ts
+ * pipeline([withSupabase({ auth: 'user' }), withBetterSupabase(sb)()], (req, ctx) => ...)
+ * ```
+ */
+export declare function withBetterSupabase<M extends AnyModels, D, F extends AnyFunctions, E>(sb: BetterSupabase<M, D, F, E>): Middleware<"db", void, SupabaseAuthContext & {
+  readonly supabase: SupabaseClient;
+}, Db<M, F, E, SupabaseClient>>;
+/**
+ * Entry contributing `ctx.sql`: repositories over `ctx.postgres` from
+ * `withPostgresClient`, which runs each query as the caller with RLS.
+ */
+export declare function withBetterPostgres<M extends AnyModels, D, F extends AnyFunctions, E>(sb: BetterSupabase<M, D, F, E>): Middleware<"sql", void, SupabaseAuthContext & {
+  readonly postgres: PostgresApi;
+}, Db<M, F, E, undefined>>;
+//#endregion
+export { AUTH_CACHE_HEADERS, type Aal, type AmrEntry, type AuthKind, type AuthResolution, type AuthResolver, type AuthState, type BetterServer, type ContextOptions, type CookieOptions, type CookieRecord, type CookieWrite, type DeleteAccountOptions, type DeleteAccountResult, type GuardOptions, type ImpersonationOptions, type Impersonator, type InvalidReason, PRIMARY_COOKIE, PROBLEM_CONTENT_TYPE, PROBLEM_TYPE_BASE, type ProblemDetails, type ProblemOptions, type ProblemResponseOptions, type RefreshOutcome, type ReplicaState, type ResolveAuthOptions, type ResolvedState, type ResourceHandler, type ResourceInput, type ResourceList, type ResourceRouteOptions, type RespondOptions, type ServerContext, type ServerOptions, type Settled, type StoredSession, type SupabaseAuthContext, aalOf, amrOf, authContext, checkAal, clientIp, createServer, defineResource, fromProblem, guard, impersonatorOf, isProblem, isResult, problemResponse, readSession, refreshSession, resolveAuth, respond, sessionCookieName, settle, toProblem, writeSession };

package/dist/server/index.js

@@ -0,0 +1,68 @@
+import { a as problemResponse, i as isProblem, n as PROBLEM_TYPE_BASE, o as toProblem, r as fromProblem, t as PROBLEM_CONTENT_TYPE } from "../problem-BTkTtRV9.js";
+import { a as settle, i as respond, n as guard, o as createServer, r as isResult, u as PRIMARY_COOKIE } from "../respond-DMcbQwfN.js";
+import { a as clientIp, f as sessionCookieName, g as impersonatorOf, i as authContext, m as refreshSession, n as amrOf, o as resolveAuth, p as writeSession, r as checkAal, s as AUTH_CACHE_HEADERS, t as aalOf, u as readSession } from "../mfa-CpLfJSde.js";
+import { n as postgresExecutor } from "../executor-DeppvirK.js";
+import { t as defineResource } from "../resource-BHEWmQJK.js";
+import { defineMiddleware } from "@supabase/middleware";
+//#region src/server/middleware.ts
+/** Repository context from a `@supabase/server` context. */
+function contextFromSupabase(ctx) {
+	switch (ctx.authMode) {
+		case "user":
+			if (!ctx.userClaims) break;
+			return {
+				actor: {
+					id: ctx.userClaims.id,
+					kind: "user",
+					...ctx.userClaims.role !== void 0 ? { role: ctx.userClaims.role } : {},
+					...ctx.userClaims.email !== void 0 ? { email: ctx.userClaims.email } : {}
+				},
+				claims: ctx.jwtClaims ?? {}
+			};
+		case "secret": return {
+			actor: {
+				id: "service",
+				kind: "service",
+				role: "service_role"
+			},
+			claims: { role: "service_role" }
+		};
+		case "publishable":
+		case "none": break;
+		default: return ctx.authMode;
+	}
+	return {
+		actor: {
+			id: "anon",
+			kind: "anon",
+			role: "anon"
+		},
+		claims: { role: "anon" }
+	};
+}
+/**
+* `@supabase/middleware` entry contributing `ctx.db`: repositories bound to
+* `ctx.supabase` (the caller-scoped client from `withSupabase`).
+*
+* ```ts
+* pipeline([withSupabase({ auth: 'user' }), withBetterSupabase(sb)()], (req, ctx) => ...)
+* ```
+*/
+function withBetterSupabase(sb) {
+	return defineMiddleware({
+		key: "db",
+		run: (_config) => (_req, ctx) => Promise.resolve({ db: sb.connect(ctx.supabase, contextFromSupabase(ctx)) })
+	});
+}
+/**
+* Entry contributing `ctx.sql`: repositories over `ctx.postgres` from
+* `withPostgresClient`, which runs each query as the caller with RLS.
+*/
+function withBetterPostgres(sb) {
+	return defineMiddleware({
+		key: "sql",
+		run: (_config) => (_req, ctx) => Promise.resolve({ sql: sb.connect(postgresExecutor(ctx.postgres), contextFromSupabase(ctx)) })
+	});
+}
+//#endregion
+export { AUTH_CACHE_HEADERS, PRIMARY_COOKIE, PROBLEM_CONTENT_TYPE, PROBLEM_TYPE_BASE, aalOf, amrOf, authContext, checkAal, clientIp, contextFromSupabase, createServer, defineResource, fromProblem, guard, impersonatorOf, isProblem, isResult, problemResponse, readSession, refreshSession, resolveAuth, respond, sessionCookieName, settle, toProblem, withBetterPostgres, withBetterSupabase, writeSession };

package/dist/session-C3LxnQ0e.d.ts

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,20 @@
+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 };

package/dist/shared-_6-uPL7E.js

@@ -0,0 +1,57 @@
+import { n as dbError, t as DbException } from "./errors-Bl3rkOzo.js";
+//#region src/plugins/shared.ts
+/** Database column name for an app column, or `undefined` if it is unknown. */
+function dbName(table, app) {
+	return app === void 0 ? void 0 : table.columns[app]?.db;
+}
+function isNull(column) {
+	return {
+		kind: "column",
+		column,
+		op: "is",
+		value: null
+	};
+}
+function isNotNull(column) {
+	return {
+		kind: "not",
+		item: isNull(column)
+	};
+}
+function equals(column, value) {
+	return {
+		kind: "column",
+		column,
+		op: "eq",
+		value
+	};
+}
+/** Sets `column` on a row unless the caller already provided it. */
+function withDefault(row, column, value) {
+	if (column === void 0 || column in row) return row;
+	return {
+		...row,
+		[column]: value
+	};
+}
+/** Upserts that may update existing rows must not overwrite "created" columns. */
+function insertsOnly(op) {
+	return !op.onConflict || op.onConflict.action === "ignore";
+}
+function forbidden(message) {
+	throw new DbException(dbError("forbidden", message));
+}
+/** Database-keyed row to app-keyed row. */
+function toApp(table, row) {
+	const out = {};
+	for (const [app, meta] of Object.entries(table.columns)) if (meta.db in row) out[app] = row[meta.db];
+	return out;
+}
+/** App-keyed row to database-keyed row. Unknown keys are dropped. */
+function toDb(table, row) {
+	const out = {};
+	for (const [app, meta] of Object.entries(table.columns)) if (app in row) out[meta.db] = row[app];
+	return out;
+}
+//#endregion
+export { isNotNull as a, toDb as c, insertsOnly as i, withDefault as l, equals as n, isNull as o, forbidden as r, toApp as s, dbName as t };