@neondatabase/auth 0.1.0-beta.2 → 0.1.0-beta.4

package/README.md

@@ -215,10 +215,12 @@ Multiple concurrent `getSession()` calls are automatically deduplicated:
 
 For Next.js projects, this package provides built-in integration via `@neondatabase/auth/next`. See the [Next.js Setup Guide](./NEXT-JS.md) for:
 
-- Creating API route handlers with `toNextJsHandler()`
-- Setting up the auth client for client components
+- Settting up the auth handler with `authApiHandler()`
+- Protecting routes with `neonAuthMiddleware()` 
+- creating the auth client with `createAuthClient()` for client components
 - Configuring the `NeonAuthUIProvider`
 - Importing styles (with or without Tailwind CSS)
+- Access session and users details with `neonAuth()` in server components
 
 ## CSS for UI Components
 

package/dist/index.mjs

@@ -1,3 +1,6 @@
+import "./adapter-core-BDOw-gBC.mjs";
+import "./better-auth-react-adapter-FnBHa2nr.mjs";
+import "./supabase-adapter-ggmqWgPe.mjs";
 import { n as createInternalNeonAuth, t as createAuthClient } from "./neon-auth-C9XTFffv.mjs";
 
 export { createAuthClient, createInternalNeonAuth };

package/dist/next/index.d.mts

@@ -5,12 +5,32 @@ import { NextRequest, NextResponse } from "next/server";
 import * as better_auth0 from "better-auth";
 import * as _better_fetch_fetch0 from "@better-fetch/fetch";
 import * as nanostores0 from "nanostores";
+import { Session, User } from "better-auth/types";
 
 //#region src/next/handler/index.d.ts
 type Params = {
   path: string[];
 };
-declare const toNextJsHandler: (baseUrl: 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
   }: {
@@ -41,23 +61,54 @@ declare const toNextJsHandler: (baseUrl: string) => {
 //#region src/next/middleware/index.d.ts
 type NeonAuthMiddlewareOptions = {
   loginUrl?: string;
-  /**
-   * The Neon Auth base URL
-   *  Defaults to `process.env.NEON_AUTH_BASE_URL`
-   *
-   * If not provided, and if not in the environment, the middleware will throw an error.
-   *
-   * @throws {Error} If the authURL is not provided and not in the environment.
-   */
-  authBaseUrl?: string;
 };
-declare const neonAuthMiddleware: ({
-  loginUrl,
-  authBaseUrl
-}: NeonAuthMiddlewareOptions) => (request: NextRequest) => Promise<NextResponse<unknown>>;
+/**
+ * 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/core/better-auth-types.d.ts
+type BetterAuthSession = Session;
+type BetterAuthUser = User;
+//#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 const createAuthClient: () => {
+declare function createAuthClient(): {
   useActiveOrganization: () => {
     data: better_auth0.Prettify<{
       id: string;
@@ -2360,4 +2411,4 @@ declare const createAuthClient: () => {
   };
 };
 //#endregion
-export { createAuthClient, neonAuthMiddleware, toNextJsHandler };
+export { authApiHandler, createAuthClient, neonAuth, neonAuthMiddleware };

package/dist/next/index.mjs

@@ -1,29 +1,99 @@
+import "../adapter-core-BDOw-gBC.mjs";
 import { t as BetterAuthReactAdapter } from "../better-auth-react-adapter-FnBHa2nr.mjs";
+import "../supabase-adapter-ggmqWgPe.mjs";
 import { t as createAuthClient$1 } from "../neon-auth-C9XTFffv.mjs";
+import { parseCookies, parseSetCookieHeader } from "better-auth/cookies";
 import { NextRequest, NextResponse } from "next/server";
+import { cookies, headers } from "next/headers";
 
+//#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",
+	NEON_AUTH_MIDDLEWARE_NOT_FOUND: "You are calling `neonAuth` on a route that is not covered by `neonAuthMiddleware`. Make sure it is running on all paths you are calling `neonAuth` from by updating your middleware config in `(middleware|proxy).(js|ts)`."
+};
+
+//#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`;
 /** Name of the session verifier parameter in the URL, used for the OAUTH flow */
 const NEON_AUTH_SESSION_VERIFIER_PARAM_NAME = "neon_auth_session_verifier";
+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("; ");
+}
+/**
+* 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"
+	"referer",
+	"content-type"
 ];
 const handleAuthRequest = async (baseUrl, request, path) => {
-	const upstreamURL = `${baseUrl}/${path}${new URL(request.url).search}`;
-	const headers = prepareRequestHeaders(request);
+	const headers$1 = prepareRequestHeaders(request);
 	const body = await parseRequestBody(request);
 	try {
-		return await fetch(upstreamURL, {
+		const upstreamURL = getUpstreamURL(baseUrl, path, { originalUrl: new URL(request.url) });
+		return await fetch(upstreamURL.toString(), {
 			method: request.method,
-			headers,
+			headers: headers$1,
 			body
 		});
 	} catch (error) {
@@ -32,29 +102,25 @@ const handleAuthRequest = async (baseUrl, request, path) => {
 		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 = new Headers();
-	headers.set("Content-Type", "application/json");
-	for (const header of PROXY_HEADERS) if (request.headers.get(header)) headers.set(header, request.headers.get(header));
-	headers.set("Origin", getOrigin(request));
-	headers.set("Cookie", extractRequestCookies(request.headers));
-	headers.set("X-Neon-Auth-Next", "true");
-	return headers;
+	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 extractRequestCookies = (headers) => {
-	const cookieHeader = headers.get("cookie");
-	if (!cookieHeader) return "";
-	const cookies = cookieHeader.split(";").map((c) => c.trim());
-	const result = [];
-	for (const cookie of cookies) {
-		const [name] = cookie.split("=");
-		if (name.startsWith(NEON_AUTH_COOKIE_PREFIX)) result.push(cookie);
-	}
-	return result.join(";");
-};
 const parseRequestBody = async (request) => {
 	if (request.body) return request.text();
 };
@@ -81,19 +147,38 @@ const handleAuthResponse = async (response) => {
 	});
 };
 const prepareResponseHeaders = (response) => {
-	const headers = new Headers();
+	const headers$1 = new Headers();
 	for (const header of RESPONSE_HEADERS_ALLOWLIST) {
 		const value = response.headers.get(header);
-		if (value) headers.set(header, value);
+		if (value) headers$1.set(header, value);
 	}
-	return headers;
+	return headers$1;
 };
 
 //#endregion
 //#region src/next/handler/index.ts
-const toNextJsHandler = (baseUrl) => {
-	const baseURL = baseUrl || process.env.NEON_AUTH_BASE_URL;
-	if (!baseURL) throw new Error("You must provide a Neon Auth base URL in the handler options or in the environment variables");
+/**
+* 
+* 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("/")));
 	};
@@ -104,42 +189,85 @@ const toNextJsHandler = (baseUrl) => {
 		DELETE: handler,
 		PATCH: handler
 	};
-};
+}
 
 //#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);
-	const hasSession = request.cookies.get(NEON_AUTH_SESSION_COOKIE_NAME);
-	return hasVerifier && hasChallenge && !hasSession;
+	return hasVerifier && hasChallenge;
 };
-const verifySession = async (request, baseUrl) => {
+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 getSession(request, baseUrl);
+	const response = await handleAuthResponse(await handleAuthRequest(baseUrl, new Request(request.url, {
+		method: "GET",
+		headers: request.headers
+	}), "get-session"));
 	if (response.ok) {
-		const headers = new Headers();
-		const cookies = extractResponseCookies(response.headers);
-		for (const cookie of cookies) headers.append("Set-Cookie", cookie);
+		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 });
+		return NextResponse.redirect(url, { headers: headers$1 });
 	}
 	return null;
 };
-const getSession = async (request, baseUrl) => {
-	return handleAuthResponse(await handleAuthRequest(baseUrl, new Request(request.url, {
-		method: "GET",
-		headers: request.headers,
-		body: null
-	}), "get-session"));
+
+//#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 () => {
+	if (!(await headers()).has(NEON_AUTH_HEADER_MIDDLEWARE_NAME)) throw new Error(ERRORS.NEON_AUTH_MIDDLEWARE_NOT_FOUND);
+	return await fetchSession();
 };
-const extractResponseCookies = (headers) => {
-	const cookieHeader = headers.get("set-cookie");
-	if (!cookieHeader) return [];
-	return cookieHeader.split(", ").map((c) => c.trim());
+/**
+* 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
@@ -153,27 +281,44 @@ const SKIP_ROUTES = [
 	"/auth/email-otp",
 	"/auth/forgot-password"
 ];
-const neonAuthMiddleware = ({ loginUrl = "/auth/sign-in", authBaseUrl }) => {
-	const baseURL = authBaseUrl || process.env.NEON_AUTH_BASE_URL;
-	if (!baseURL) throw new Error("You must provide a Neon Auth base URL in the middleware options or in the environment variables");
+/** 
+* 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 verifySession(request, baseURL);
+			const response = await exchangeOAuthToken(request, baseUrl);
 			if (response !== null) return response;
 		}
 		if (SKIP_ROUTES.some((route) => pathname.startsWith(route))) return NextResponse.next();
-		if (!request.cookies.get(NEON_AUTH_SESSION_COOKIE_NAME)) return NextResponse.redirect(new URL(loginUrl, request.url));
-		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 } });
 	};
-};
+}
 
 //#endregion
 //#region src/next/index.ts
-const createAuthClient = () => {
+function createAuthClient() {
 	return createAuthClient$1(void 0, { adapter: BetterAuthReactAdapter() });
-};
+}
 
 //#endregion
-export { createAuthClient, neonAuthMiddleware, toNextJsHandler };
+export { authApiHandler, createAuthClient, neonAuth, neonAuthMiddleware };

package/dist/react/adapters/index.mjs

@@ -1,3 +1,5 @@
+import "../../adapter-core-BDOw-gBC.mjs";
 import { t as BetterAuthReactAdapter } from "../../better-auth-react-adapter-FnBHa2nr.mjs";
+import "../../adapters-Dkx0zoMR.mjs";
 
 export { BetterAuthReactAdapter };

package/dist/react/index.mjs

@@ -1,5 +1,7 @@
-import { n as dist_exports, r as useTheme, t as NeonAuthUIProvider } from "../ui-CNFBSekF.mjs";
+import { n as dist_exports, r as useTheme, t as NeonAuthUIProvider } from "../ui-BQAaHqx4.mjs";
+import "../adapter-core-BDOw-gBC.mjs";
 import { t as BetterAuthReactAdapter } from "../better-auth-react-adapter-FnBHa2nr.mjs";
+import "../adapters-Dkx0zoMR.mjs";
 
 var AcceptInvitationCard = dist_exports.AcceptInvitationCard;
 var AccountSettingsCards = dist_exports.AccountSettingsCards;

package/dist/react/ui/index.mjs

@@ -1,5 +1,5 @@
 'use client';
-import { n as dist_exports, r as useTheme, t as NeonAuthUIProvider } from "../../ui-CNFBSekF.mjs";
+import { n as dist_exports, r as useTheme, t as NeonAuthUIProvider } from "../../ui-BQAaHqx4.mjs";
 
 var AcceptInvitationCard = dist_exports.AcceptInvitationCard;
 var AccountSettingsCards = dist_exports.AccountSettingsCards;

package/dist/{ui-CNFBSekF.mjs → ui-BQAaHqx4.mjs}

@@ -10,40 +10,25 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (all, symbols) => {
+var __export = (all) => {
 	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
 	return target;
 };
 var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
 	}
 	return to;
 };
-var __reExport = (target, mod, secondTarget, symbols) => {
-	if (symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-		secondTarget && __defProp(secondTarget, Symbol.toStringTag, { value: "Module" });
-	}
-	__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default");
-};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 
 //#endregion
 //#region ../auth-ui/dist/index.mjs

package/dist/vanilla/adapters/index.mjs

@@ -1,3 +1,5 @@
+import "../../adapter-core-BDOw-gBC.mjs";
 import { n as BetterAuthVanillaAdapter, t as SupabaseAuthAdapter } from "../../supabase-adapter-ggmqWgPe.mjs";
+import "../../adapters-CivF9wql.mjs";
 
 export { BetterAuthVanillaAdapter, SupabaseAuthAdapter };

package/dist/vanilla/index.mjs

@@ -1,3 +1,5 @@
+import "../adapter-core-BDOw-gBC.mjs";
 import { n as BetterAuthVanillaAdapter, t as SupabaseAuthAdapter } from "../supabase-adapter-ggmqWgPe.mjs";
+import "../adapters-CivF9wql.mjs";
 
 export { BetterAuthVanillaAdapter, SupabaseAuthAdapter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neondatabase/auth",
-  "version": "0.1.0-beta.2",
+  "version": "0.1.0-beta.4",
   "description": "TypeScript SDK for Neon Auth - authentication for PostgreSQL with multiple adapter support",
   "type": "module",
   "license": "Apache-2.0",