@neondatabase/auth 0.1.0-beta.15 → 0.1.0-beta.17

package/dist/neon-auth-DDPaciiS.d.mts

@@ -0,0 +1,105 @@
+import { r as SupportedBetterAuthClientPlugins } from "./adapter-core-Sx7jkLdB.mjs";
+import { r as BetterAuthReactAdapterInstance } from "./better-auth-react-adapter-BWH-XVdf.mjs";
+import { r as SupabaseAuthAdapterInstance, s as BetterAuthVanillaAdapterInstance } from "./supabase-adapter-k8RBezY9.mjs";
+import { createAuthClient } from "better-auth/react";
+import { createAuthClient as createAuthClient$1 } from "better-auth/client";
+
+//#region src/neon-auth.d.ts
+
+/**
+ * Type representing the Better Auth React client
+ */
+type ReactBetterAuthClient = ReturnType<typeof createAuthClient<{
+  plugins: SupportedBetterAuthClientPlugins;
+}>>;
+/**`
+ * Type representing the Better Auth Vanilla client
+ */
+type VanillaBetterAuthClient = ReturnType<typeof createAuthClient$1<{
+  plugins: SupportedBetterAuthClientPlugins;
+}>>;
+/**
+ * Union type of all supported auth adapter instances
+ */
+type NeonAuthAdapter = BetterAuthVanillaAdapterInstance | BetterAuthReactAdapterInstance | SupabaseAuthAdapterInstance;
+/**
+ * Configuration for createAuthClient
+ */
+interface NeonAuthConfig<T extends NeonAuthAdapter> {
+  /** The adapter builder to use. Defaults to BetterAuthVanillaAdapter() if not specified. */
+  adapter?: (url: string) => T;
+  /**
+   * When true, automatically uses an anonymous token when no user session exists.
+   * This enables RLS-based data access for users with the anonymous role.
+   * @default false
+   */
+  allowAnonymous?: boolean;
+}
+/**
+ * Resolves the public API type for an adapter.
+ * - SupabaseAuthAdapter: exposes its own methods directly (Supabase-compatible API)
+ * - BetterAuth adapters: expose the Better Auth client directly
+ */
+type NeonAuthPublicApi<T extends NeonAuthAdapter> = T extends BetterAuthVanillaAdapterInstance ? VanillaBetterAuthClient : T extends BetterAuthReactAdapterInstance ? ReactBetterAuthClient : T;
+/**
+ * NeonAuth type - combines base functionality with the appropriate public API
+ * This is the return type of createAuthClient()
+ *
+ * For SupabaseAuthAdapter: exposes Supabase-compatible methods (signInWithPassword, getSession, etc.)
+ * For BetterAuth adapters: exposes the Better Auth client directly (signIn.email, signUp.email, etc.)
+ */
+type NeonAuth<T extends NeonAuthAdapter> = {
+  adapter: NeonAuthPublicApi<T>;
+  getJWTToken: () => Promise<string | null>;
+};
+/**
+ * Create a NeonAuth instance that exposes the appropriate API based on the adapter.
+ *
+ * @param url - The auth service URL (e.g., 'https://auth.example.com')
+ * @param config - Configuration with adapter builder
+ * @returns NeonAuth instance with the adapter's API exposed directly
+ *
+ * @example SupabaseAuthAdapter - Supabase-compatible API
+ * ```typescript
+ * import { createAuthClient, SupabaseAuthAdapter } from '@neondatabase/auth';
+ *
+ * const auth = createAuthClient('https://auth.example.com', {
+ *   adapter: SupabaseAuthAdapter(),
+ * });
+ *
+ * // Supabase-compatible methods
+ * await auth.signInWithPassword({ email, password });
+ * await auth.getSession();
+ * ```
+ *
+ * @example BetterAuthVanillaAdapter - Direct Better Auth API
+ * ```typescript
+ * import { createAuthClient, BetterAuthVanillaAdapter } from '@neondatabase/auth';
+ *
+ * const auth = createAuthClient('https://auth.example.com', {
+ *   adapter: BetterAuthVanillaAdapter(),
+ * });
+ *
+ * // Direct Better Auth API access
+ * await auth.signIn.email({ email, password });
+ * await auth.signUp.email({ email, password, name: 'John' });
+ * await auth.getSession();
+ * ```
+ *
+ * @example BetterAuthReactAdapter - Better Auth with React hooks
+ * ```typescript
+ * import { createAuthClient, BetterAuthReactAdapter } from '@neondatabase/auth';
+ *
+ * const auth = createAuthClient('https://auth.example.com', {
+ *   adapter: BetterAuthReactAdapter(),
+ * });
+ *
+ * // Direct Better Auth API with React hooks
+ * await auth.signIn.email({ email, password });
+ * const session = auth.useSession(); // React hook
+ * ```
+ */
+declare function createInternalNeonAuth<T extends NeonAuthAdapter = BetterAuthVanillaAdapterInstance>(url: string, config?: NeonAuthConfig<T>): NeonAuth<T>;
+declare function createAuthClient$2<T extends NeonAuthAdapter = BetterAuthVanillaAdapterInstance>(url: string, config?: NeonAuthConfig<T>): NeonAuthPublicApi<T>;
+//#endregion
+export { ReactBetterAuthClient as a, createInternalNeonAuth as c, NeonAuthPublicApi as i, NeonAuthAdapter as n, VanillaBetterAuthClient as o, NeonAuthConfig as r, createAuthClient$2 as s, NeonAuth as t };

package/dist/next/index.d.mts

@@ -1,108 +1,13 @@
-import { n as BetterAuthSession, r as BetterAuthUser } from "../better-auth-types-VqadyqlG.mjs";
+import "../better-auth-types-Kq3kGuiz.mjs";
+import { n as SessionData, t as neonAuthMiddleware$1 } from "../index-B4dy0AqC.mjs";
 import * as better_auth_client0 from "better-auth/client";
 import * as better_auth_client_plugins0 from "better-auth/client/plugins";
 import * as jose0 from "jose";
-import { NextRequest, NextResponse } from "next/server";
+import * as next_server0 from "next/server";
 import * as better_auth0 from "better-auth";
 import * as _better_fetch_fetch0 from "@better-fetch/fetch";
 import * as nanostores0 from "nanostores";
 
-//#region src/next/handler/index.d.ts
-type Params = {
-  path: string[];
-};
-/**
- *
- * An API route handler to handle the auth requests from the client and proxy them to the Neon Auth.
- *
- * @returns A Next.js API handler functions those can be used in a Next.js route.
- *
- * @example
- *
- * Mount the `authApiHandler` to an API route. Create a route file inside `/api/auth/[...all]/route.ts` directory.
- *  And add the following code:
- *
- * ```ts
- *
- * import { authApiHandler } from '@neondatabase/auth/next';
- *
- * export const { GET, POST } = authApiHandler();
- * ```
- *
- */
-declare function authApiHandler(): {
-  GET: (request: Request, {
-    params
-  }: {
-    params: Promise<Params>;
-  }) => Promise<Response>;
-  POST: (request: Request, {
-    params
-  }: {
-    params: Promise<Params>;
-  }) => Promise<Response>;
-  PUT: (request: Request, {
-    params
-  }: {
-    params: Promise<Params>;
-  }) => Promise<Response>;
-  DELETE: (request: Request, {
-    params
-  }: {
-    params: Promise<Params>;
-  }) => Promise<Response>;
-  PATCH: (request: Request, {
-    params
-  }: {
-    params: Promise<Params>;
-  }) => Promise<Response>;
-};
-//#endregion
-//#region src/next/middleware/index.d.ts
-type NeonAuthMiddlewareOptions = {
-  loginUrl?: string;
-};
-/**
- * A Next.js middleware to protect routes from unauthenticated requests and refresh the session if required.
- *
- * @param loginUrl - The URL to redirect to when the user is not authenticated.
- * @returns A middleware function that can be used in the Next.js app.
- *
- * @example
- * ```ts
- * import { neonAuthMiddleware } from "@neondatabase/auth/next"
- *
- * export default neonAuthMiddleware({
- *   loginUrl: '/auth/sign-in',
- * });
- * ```
- */
-declare function neonAuthMiddleware({
-  loginUrl
-}: NeonAuthMiddlewareOptions): (request: NextRequest) => Promise<NextResponse<unknown>>;
-//#endregion
-//#region src/next/auth/session.d.ts
-type SessionData = {
-  session: BetterAuthSession;
-  user: BetterAuthUser;
-} | {
-  session: null;
-  user: null;
-};
-/**
- * A utility function to be used in react server components fetch the session details from the Neon Auth API, if session token is available in cookie.
- *
- * @returns - `{ session: Session, user: User }` | `{ session: null, user: null}`.
- *
- * @example
- * ```ts
- * import { neonAuth } from "@neondatabase/auth/next"
- *
- * const { session, user } = await neonAuth()
- * ```
- */
-declare const neonAuth: () => Promise<SessionData>;
-//#endregion
 //#region src/next/index.d.ts
 declare function createAuthClient(): {
   useActiveOrganization: () => {
@@ -2230,5 +2135,65 @@ declare function createAuthClient(): {
     readonly USER_ALREADY_HAS_PASSWORD: "User already has a password. Provide that to delete the account.";
   };
 };
+/**
+ * @deprecated
+ * - Moved to `@neondatabase/auth/next/server` and
+ * - Moved to `@neondatabase/neon-js/auth/next/server`
+ *
+ * An API route handler to handle the auth requests from the client and proxy them to the Neon Auth.
+ */
+declare function authApiHandler(): {
+  GET: (request: Request, {
+    params
+  }: {
+    params: Promise<{
+      path: string[];
+    }>;
+  }) => Promise<Response>;
+  POST: (request: Request, {
+    params
+  }: {
+    params: Promise<{
+      path: string[];
+    }>;
+  }) => Promise<Response>;
+  PUT: (request: Request, {
+    params
+  }: {
+    params: Promise<{
+      path: string[];
+    }>;
+  }) => Promise<Response>;
+  DELETE: (request: Request, {
+    params
+  }: {
+    params: Promise<{
+      path: string[];
+    }>;
+  }) => Promise<Response>;
+  PATCH: (request: Request, {
+    params
+  }: {
+    params: Promise<{
+      path: string[];
+    }>;
+  }) => Promise<Response>;
+};
+/**
+ * @deprecated
+ * - Moved to `@neondatabase/auth/next/server` and
+ * - Moved to `@neondatabase/neon-js/auth/next/server`
+ *
+ * A Next.js middleware to protect routes from unauthenticated requests and refresh the session if required.
+ */
+declare function neonAuthMiddleware(args: Parameters<typeof neonAuthMiddleware$1>[0]): (request: next_server0.NextRequest) => Promise<next_server0.NextResponse<unknown>>;
+/**
+ * @deprecated
+ * - Moved to `@neondatabase/auth/next/server` and
+ * - Moved to `@neondatabase/neon-js/auth/next/server`
+ *
+ * A utility function to be used in react server components fetch the session details from the Neon Auth API, if session token is available in cookie.
+ */
+declare function neonAuth(): Promise<SessionData>;
 //#endregion
 export { authApiHandler, createAuthClient, neonAuth, neonAuthMiddleware };

package/dist/next/index.mjs

@@ -1,316 +1,41 @@
-import { o as NEON_AUTH_SESSION_VERIFIER_PARAM_NAME } from "../adapter-core-ChIlSbGg.mjs";
-import { t as BetterAuthReactAdapter } from "../better-auth-react-adapter-C3_WRaIy.mjs";
-import { t as createAuthClient$1 } from "../neon-auth-sSiNq4zM.mjs";
-import { parseCookies, parseSetCookieHeader } from "better-auth/cookies";
-import { NextRequest, NextResponse } from "next/server";
-import { cookies, headers } from "next/headers";
+import "../adapter-core-BQ6ga1zK.mjs";
+import { t as BetterAuthReactAdapter } from "../better-auth-react-adapter-BLKXYcWM.mjs";
+import { t as createAuthClient$1 } from "../neon-auth-ClDZNB9a.mjs";
+import { n as neonAuth$1, r as authApiHandler$1, t as neonAuthMiddleware$1 } from "../middleware-DPLYghmx.mjs";
 
-//#region src/next/errors.ts
-const ERRORS = { MISSING_AUTH_BASE_URL: "Missing environment variable: NEON_AUTH_BASE_URL. \n You must provide the auth url of your Neon Auth instance in environment variables" };
-
-//#endregion
-//#region src/next/constants.ts
-const NEON_AUTH_COOKIE_PREFIX = "__Secure-neon-auth";
-const NEON_AUTH_SESSION_COOKIE_NAME = `${NEON_AUTH_COOKIE_PREFIX}.session_token`;
-const NEON_AUTH_SESSION_CHALLENGE_COOKIE_NAME = `${NEON_AUTH_COOKIE_PREFIX}.session_challange`;
-const NEON_AUTH_HEADER_MIDDLEWARE_NAME = "X-Neon-Auth-Next-Middleware";
-
-//#endregion
-//#region src/next/auth/cookies.ts
-/**
-* Extract the Neon Auth cookies from the request headers that starts with the NEON_AUTH_COOKIE_PREFIX.
-* 
-* @param headers - The request headers.
-* @returns The cookie string with all Neon Auth cookies.
-*/
-function extractRequestCookies(headers$1) {
-	const cookieHeader = headers$1.get("cookie");
-	if (!cookieHeader) return "";
-	const parsedCookies = parseCookies(cookieHeader);
-	const result = [];
-	for (const [name, value] of parsedCookies.entries()) if (name.startsWith(NEON_AUTH_COOKIE_PREFIX)) result.push({
-		name,
-		value
-	});
-	return result.map((cookie) => cookie.name + "=" + cookie.value).join("; ");
+//#region src/next/index.ts
+function createAuthClient() {
+	return createAuthClient$1(void 0, { adapter: BetterAuthReactAdapter() });
 }
 /**
-* Extract the Neon Auth cookies from the response headers that starts with the NEON_AUTH_COOKIE_PREFIX.
-* 
-* @param headers - The response headers.
-* @returns The cookies that starts with the NEON_AUTH_COOKIE_PREFIX.
-*/
-const extractResponseCookies = (headers$1) => {
-	const cookieHeader = headers$1.get("set-cookie");
-	if (!cookieHeader) return [];
-	return cookieHeader.split(", ").map((c) => c.trim());
-};
-/**
-* 
-* Parses the `set-cookie` header from Neon Auth response into the list of ResponseCookies,
-*  compatible with NextCookies.
-* 
-* @param cookies - The `set-cookie` header from Neon Auth response.
-* @returns The list of ResponseCookies.
-*/
-const parseSetCookies = (cookies$1) => {
-	const parsedCookies = parseSetCookieHeader(cookies$1);
-	const responseCookies = [];
-	for (const entry of parsedCookies.entries()) {
-		const [name, parsedCookie] = entry;
-		responseCookies.push({
-			name,
-			value: decodeURIComponent(parsedCookie.value),
-			path: parsedCookie.path,
-			maxAge: parsedCookie["max-age"] ?? parsedCookie.maxAge,
-			httpOnly: parsedCookie.httponly ?? true,
-			secure: parsedCookie.secure ?? true,
-			sameSite: parsedCookie.samesite ?? "none",
-			partitioned: parsedCookie.partitioned
-		});
-	}
-	return responseCookies;
-};
-
-//#endregion
-//#region src/next/handler/request.ts
-const PROXY_HEADERS = [
-	"user-agent",
-	"authorization",
-	"referer",
-	"content-type"
-];
-const handleAuthRequest = async (baseUrl, request, path) => {
-	const headers$1 = prepareRequestHeaders(request);
-	const body = await parseRequestBody(request);
-	try {
-		const upstreamURL = getUpstreamURL(baseUrl, path, { originalUrl: new URL(request.url) });
-		return await fetch(upstreamURL.toString(), {
-			method: request.method,
-			headers: headers$1,
-			body
-		});
-	} catch (error) {
-		const message = error instanceof Error ? error.message : "Internal Server Error";
-		console.error(`[AuthError] ${message}`, error);
-		return new Response(`[AuthError] ${message}`, { status: 500 });
-	}
-};
-const getUpstreamURL = (baseUrl, path, { originalUrl }) => {
-	const url = new URL(`${baseUrl}/${path}`);
-	if (originalUrl) {
-		url.search = originalUrl.search;
-		return url;
-	}
-	return url;
-};
-const prepareRequestHeaders = (request) => {
-	const headers$1 = new Headers();
-	for (const header of PROXY_HEADERS) if (request.headers.get(header)) headers$1.set(header, request.headers.get(header));
-	headers$1.set("Origin", getOrigin(request));
-	headers$1.set("Cookie", extractRequestCookies(request.headers));
-	headers$1.set(NEON_AUTH_HEADER_MIDDLEWARE_NAME, "true");
-	return headers$1;
-};
-const getOrigin = (request) => {
-	return request.headers.get("origin") || request.headers.get("referer")?.split("/").slice(0, 3).join("/") || new URL(request.url).origin;
-};
-const parseRequestBody = async (request) => {
-	if (request.body) return request.text();
-};
-
-//#endregion
-//#region src/next/handler/response.ts
-const RESPONSE_HEADERS_ALLOWLIST = [
-	"content-type",
-	"content-length",
-	"content-encoding",
-	"transfer-encoding",
-	"connection",
-	"date",
-	"set-cookie",
-	"set-auth-jwt",
-	"set-auth-token",
-	"x-neon-ret-request-id"
-];
-const handleAuthResponse = async (response) => {
-	return new Response(response.body, {
-		status: response.status,
-		statusText: response.statusText,
-		headers: prepareResponseHeaders(response)
-	});
-};
-const prepareResponseHeaders = (response) => {
-	const headers$1 = new Headers();
-	for (const header of RESPONSE_HEADERS_ALLOWLIST) {
-		const value = response.headers.get(header);
-		if (value) headers$1.set(header, value);
-	}
-	return headers$1;
-};
-
-//#endregion
-//#region src/next/handler/index.ts
-/**
+* @deprecated 
+* - Moved to `@neondatabase/auth/next/server` and 
+* - Moved to `@neondatabase/neon-js/auth/next/server` 
 * 
 * An API route handler to handle the auth requests from the client and proxy them to the Neon Auth.
-* 
-* @returns A Next.js API handler functions those can be used in a Next.js route.
-*
-* @example
-* 
-* Mount the `authApiHandler` to an API route. Create a route file inside `/api/auth/[...all]/route.ts` directory. 
-*  And add the following code:
-* 
-* ```ts 
-* 
-* import { authApiHandler } from '@neondatabase/auth/next';
-* 
-* export const { GET, POST } = authApiHandler();
-* ```
-* 
 */
 function authApiHandler() {
-	const baseURL = process.env.NEON_AUTH_BASE_URL;
-	if (!baseURL) throw new Error(ERRORS.MISSING_AUTH_BASE_URL);
-	const handler = async (request, { params }) => {
-		return await handleAuthResponse(await handleAuthRequest(baseURL, request, (await params).path.join("/")));
-	};
-	return {
-		GET: handler,
-		POST: handler,
-		PUT: handler,
-		DELETE: handler,
-		PATCH: handler
-	};
+	return authApiHandler$1();
 }
-
-//#endregion
-//#region src/next/middleware/oauth.ts
-const needsSessionVerification = (request) => {
-	const hasVerifier = request.nextUrl.searchParams.has(NEON_AUTH_SESSION_VERIFIER_PARAM_NAME);
-	const hasChallenge = request.cookies.get(NEON_AUTH_SESSION_CHALLENGE_COOKIE_NAME);
-	return hasVerifier && hasChallenge;
-};
-const exchangeOAuthToken = async (request, baseUrl) => {
-	const url = request.nextUrl;
-	const verifier = url.searchParams.get(NEON_AUTH_SESSION_VERIFIER_PARAM_NAME);
-	const challenge = request.cookies.get(NEON_AUTH_SESSION_CHALLENGE_COOKIE_NAME);
-	if (!verifier || !challenge) return null;
-	const response = await handleAuthResponse(await handleAuthRequest(baseUrl, new Request(request.url, {
-		method: "GET",
-		headers: request.headers
-	}), "get-session"));
-	if (response.ok) {
-		const headers$1 = new Headers();
-		const cookies$1 = extractResponseCookies(response.headers);
-		for (const cookie of cookies$1) headers$1.append("Set-Cookie", cookie);
-		url.searchParams.delete(NEON_AUTH_SESSION_VERIFIER_PARAM_NAME);
-		return NextResponse.redirect(url, { headers: headers$1 });
-	}
-	return null;
-};
-
-//#endregion
-//#region src/next/env-variables.ts
-const NEON_AUTH_BASE_URL = process.env.NEON_AUTH_BASE_URL;
-
-//#endregion
-//#region src/next/auth/session.ts
-/**
-* A utility function to be used in react server components fetch the session details from the Neon Auth API, if session token is available in cookie.
-*
-* @returns - `{ session: Session, user: User }` | `{ session: null, user: null}`.
-*
-* @example
-* ```ts
-* import { neonAuth } from "@neondatabase/auth/next"
-*
-* const { session, user } = await neonAuth()
-* ```
-*/
-const neonAuth = async () => {
-	return await fetchSession();
-};
-/**
-* A utility function to fetch the session details from the Neon Auth API, if session token is available in cookie.
-*
-* @returns - `{ session: Session, user: User }` | `{ session: null, user: null}`.
-*/
-const fetchSession = async () => {
-	const baseUrl = NEON_AUTH_BASE_URL;
-	const requestHeaders = await headers();
-	const upstreamURL = getUpstreamURL(baseUrl, "get-session", { originalUrl: new URL("get-session", baseUrl) });
-	const response = await fetch(upstreamURL.toString(), {
-		method: "GET",
-		headers: { Cookie: extractRequestCookies(requestHeaders) }
-	});
-	const body = await response.json();
-	const cookieHeader = response.headers.get("set-cookie");
-	if (cookieHeader) {
-		const cookieStore = await cookies();
-		parseSetCookies(cookieHeader).map((cookie) => {
-			cookieStore.set(cookie.name, cookie.value, cookie);
-		});
-	}
-	if (!response.ok || body === null) return {
-		session: null,
-		user: null
-	};
-	return {
-		session: body.session,
-		user: body.user
-	};
-};
-
-//#endregion
-//#region src/next/middleware/index.ts
-const SKIP_ROUTES = [
-	"/api/auth",
-	"/auth/callback",
-	"/auth/sign-in",
-	"/auth/sign-up",
-	"/auth/magic-link",
-	"/auth/email-otp",
-	"/auth/forgot-password"
-];
 /**
+* @deprecated 
+* - Moved to `@neondatabase/auth/next/server` and 
+* - Moved to `@neondatabase/neon-js/auth/next/server` 
+* 
 * A Next.js middleware to protect routes from unauthenticated requests and refresh the session if required.
-*
-* @param loginUrl - The URL to redirect to when the user is not authenticated.
-* @returns A middleware function that can be used in the Next.js app.
-*
-* @example
-* ```ts
-* import { neonAuthMiddleware } from "@neondatabase/auth/next"
-*
-* export default neonAuthMiddleware({
-*   loginUrl: '/auth/sign-in',
-* });
-* ```
 */
-function neonAuthMiddleware({ loginUrl = "/auth/sign-in" }) {
-	const baseUrl = NEON_AUTH_BASE_URL;
-	if (!baseUrl) throw new Error(ERRORS.MISSING_AUTH_BASE_URL);
-	return async (request) => {
-		const { pathname } = request.nextUrl;
-		if (pathname.startsWith(loginUrl)) return NextResponse.next();
-		if (needsSessionVerification(request)) {
-			const response = await exchangeOAuthToken(request, baseUrl);
-			if (response !== null) return response;
-		}
-		if (SKIP_ROUTES.some((route) => pathname.startsWith(route))) return NextResponse.next();
-		if ((await fetchSession()).session === null) return NextResponse.redirect(new URL(loginUrl, request.url));
-		const reqHeaders = new Headers(request.headers);
-		reqHeaders.set(NEON_AUTH_HEADER_MIDDLEWARE_NAME, "true");
-		return NextResponse.next({ request: { headers: reqHeaders } });
-	};
+function neonAuthMiddleware(args) {
+	return neonAuthMiddleware$1(args);
 }
-
-//#endregion
-//#region src/next/index.ts
-function createAuthClient() {
-	return createAuthClient$1(void 0, { adapter: BetterAuthReactAdapter() });
+/**
+* @deprecated 
+* - Moved to `@neondatabase/auth/next/server` and 
+* - Moved to `@neondatabase/neon-js/auth/next/server` 
+* 
+* A utility function to be used in react server components fetch the session details from the Neon Auth API, if session token is available in cookie.
+*/
+function neonAuth() {
+	return neonAuth$1();
 }
 
 //#endregion