better-auth-studio 1.1.2-beta.15 → 1.1.2-beta.17

package/dist/core/handler.js

@@ -1,11 +1,11 @@
-import { existsSync, readFileSync, realpathSync, statSync } from 'fs';
-import { dirname, extname, join, resolve } from 'path';
-import { fileURLToPath } from 'url';
-import { createClickHouseProvider, createHttpProvider, createPostgresProvider, createSqliteProvider, createStorageProvider, } from '../providers/events/helpers.js';
-import { initializeEventIngestion, isEventIngestionInitialized } from '../utils/event-ingestion.js';
-import { injectEventHooks } from '../utils/hook-injector.js';
-import { serveIndexHtml as getIndexHtml } from '../utils/html-injector.js';
-import { decryptSession, isSessionValid, STUDIO_COOKIE_NAME } from '../utils/session.js';
+import { existsSync, readFileSync, realpathSync, statSync } from "fs";
+import { dirname, extname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { createClickHouseProvider, createHttpProvider, createPostgresProvider, createSqliteProvider, createStorageProvider, } from "../providers/events/helpers.js";
+import { initializeEventIngestion, isEventIngestionInitialized } from "../utils/event-ingestion.js";
+import { injectEventHooks } from "../utils/hook-injector.js";
+import { serveIndexHtml as getIndexHtml } from "../utils/html-injector.js";
+import { decryptSession, isSessionValid, STUDIO_COOKIE_NAME } from "../utils/session.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const __realdir = (() => {
@@ -23,15 +23,15 @@ export async function initializeEventIngestionAndHooks(config) {
     if (config.events?.enabled && !isEventIngestionInitialized()) {
         let provider;
         if (config.events.provider &&
-            typeof config.events.provider === 'object' &&
-            typeof config.events.provider.ingest === 'function') {
+            typeof config.events.provider === "object" &&
+            typeof config.events.provider.ingest === "function") {
             provider = config.events.provider;
         }
         else if (config.events.client && config.events.clientType) {
             switch (config.events.clientType) {
-                case 'postgres':
-                case 'prisma':
-                case 'drizzle':
+                case "postgres":
+                case "prisma":
+                case "drizzle":
                     try {
                         provider = createPostgresProvider({
                             client: config.events.client,
@@ -43,7 +43,7 @@ export async function initializeEventIngestionAndHooks(config) {
                         throw error;
                     }
                     break;
-                case 'sqlite':
+                case "sqlite":
                     try {
                         provider = createSqliteProvider({
                             client: config.events.client,
@@ -54,13 +54,13 @@ export async function initializeEventIngestionAndHooks(config) {
                         throw error;
                     }
                     break;
-                case 'clickhouse':
+                case "clickhouse":
                     provider = createClickHouseProvider({
                         client: config.events.client,
                         table: config.events.tableName,
                     });
                     break;
-                case 'http':
+                case "http":
                     provider = createHttpProvider({
                         url: config.events.client,
                         headers: config.events.headers || {},
@@ -73,7 +73,7 @@ export async function initializeEventIngestionAndHooks(config) {
             if (authAdapter) {
                 provider = createStorageProvider({
                     adapter: authAdapter,
-                    tableName: config.events.tableName || 'auth_events',
+                    tableName: config.events.tableName || "auth_events",
                 });
             }
         }
@@ -95,62 +95,62 @@ export async function initializeEventIngestionAndHooks(config) {
 export async function handleStudioRequest(request, config) {
     try {
         const isSelfHosted = !!config.basePath;
-        const basePath = config.basePath || '';
+        const basePath = config.basePath || "";
         let path = request.url;
-        const [pathname, queryString] = path.split('?');
+        const [pathname, queryString] = path.split("?");
         if (isSelfHosted && basePath) {
-            const normalizedBasePath = basePath.endsWith('/') ? basePath.slice(0, -1) : basePath;
+            const normalizedBasePath = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
             let normalizedPath = pathname;
-            if (normalizedPath === normalizedBasePath || normalizedPath === normalizedBasePath + '/') {
-                normalizedPath = '/';
+            if (normalizedPath === normalizedBasePath || normalizedPath === normalizedBasePath + "/") {
+                normalizedPath = "/";
             }
-            else if (normalizedPath.startsWith(normalizedBasePath + '/')) {
+            else if (normalizedPath.startsWith(normalizedBasePath + "/")) {
                 normalizedPath = normalizedPath.slice(normalizedBasePath.length);
             }
             else if (normalizedPath.startsWith(normalizedBasePath)) {
-                normalizedPath = normalizedPath.slice(normalizedBasePath.length) || '/';
+                normalizedPath = normalizedPath.slice(normalizedBasePath.length) || "/";
             }
-            path = normalizedPath + (queryString ? '?' + queryString : '');
+            path = normalizedPath + (queryString ? "?" + queryString : "");
         }
         else {
-            path = pathname + (queryString ? '?' + queryString : '');
+            path = pathname + (queryString ? "?" + queryString : "");
         }
-        if (path === '' || path === '/') {
-            path = '/';
+        if (path === "" || path === "/") {
+            path = "/";
         }
-        if (path.startsWith('/assets/') ||
-            path === '/vite.svg' ||
-            path === '/favicon.svg' ||
-            path === '/logo.png') {
+        if (path.startsWith("/assets/") ||
+            path === "/vite.svg" ||
+            path === "/favicon.svg" ||
+            path === "/logo.png") {
             return handleStaticFile(path, config);
         }
-        if (path === '/') {
+        if (path === "/") {
             return handleStaticFile(path, config);
         }
-        const spaRoutes = ['/login', '/access-denied'];
-        if (spaRoutes.some((r) => path === r || path.startsWith(r + '?'))) {
+        const spaRoutes = ["/login", "/access-denied"];
+        if (spaRoutes.some((r) => path === r || path.startsWith(r + "?"))) {
             return handleStaticFile(path, config);
         }
-        if (path.startsWith('/api/')) {
+        if (path.startsWith("/api/")) {
             if (isSelfHosted && isProtectedApiPath(path)) {
                 const sessionResult = verifyStudioSession(request, config);
                 if (!sessionResult.valid) {
-                    return jsonResponse(401, { error: 'Unauthorized', message: sessionResult.error });
+                    return jsonResponse(401, { error: "Unauthorized", message: sessionResult.error });
                 }
             }
             return await handleApiRoute(request, path, config);
         }
         if (isSelfHosted) {
-            const acceptHeader = request.headers['accept'] || request.headers['Accept'] || '';
-            const wantsJson = acceptHeader.includes('application/json') ||
-                acceptHeader === '*/*' ||
-                !acceptHeader.includes('text/html');
+            const acceptHeader = request.headers["accept"] || request.headers["Accept"] || "";
+            const wantsJson = acceptHeader.includes("application/json") ||
+                acceptHeader === "*/*" ||
+                !acceptHeader.includes("text/html");
             if (wantsJson) {
-                const apiPath = '/api' + path;
+                const apiPath = "/api" + path;
                 if (isProtectedApiPath(apiPath)) {
                     const sessionResult = verifyStudioSession(request, config);
                     if (!sessionResult.valid) {
-                        return jsonResponse(401, { error: 'Unauthorized', message: sessionResult.error });
+                        return jsonResponse(401, { error: "Unauthorized", message: sessionResult.error });
                     }
                 }
                 return await handleApiRoute(request, apiPath, config);
@@ -161,10 +161,10 @@ export async function handleStudioRequest(request, config) {
         return handleStaticFile(path, config);
     }
     catch (error) {
-        console.error('Studio handler error:', error);
+        console.error("Studio handler error:", error);
         return jsonResponse(500, {
-            error: 'Internal server error',
-            message: error instanceof Error ? error.message : 'Unknown error',
+            error: "Internal server error",
+            message: error instanceof Error ? error.message : "Unknown error",
         });
     }
 }
@@ -192,46 +192,46 @@ function getSessionSecret(config) {
     return (config.access?.secret ||
         config.auth?.options?.secret ||
         process.env.BETTER_AUTH_SECRET ||
-        'studio-default-secret');
+        "studio-default-secret");
 }
 function parseCookies(cookieHeader) {
     if (!cookieHeader)
         return {};
     const cookies = {};
-    cookieHeader.split(';').forEach((part) => {
-        const [name, ...rest] = part.trim().split('=');
+    cookieHeader.split(";").forEach((part) => {
+        const [name, ...rest] = part.trim().split("=");
         if (name) {
-            cookies[name] = rest.join('=');
+            cookies[name] = rest.join("=");
         }
     });
     return cookies;
 }
 function verifyStudioSession(request, config) {
-    const cookieHeader = request.headers['cookie'] || request.headers['Cookie'];
+    const cookieHeader = request.headers["cookie"] || request.headers["Cookie"];
     const cookies = parseCookies(cookieHeader);
     const sessionCookie = cookies[STUDIO_COOKIE_NAME];
     if (!sessionCookie) {
-        return { valid: false, error: 'No session cookie' };
+        return { valid: false, error: "No session cookie" };
     }
     const session = decryptSession(sessionCookie, getSessionSecret(config));
     if (!isSessionValid(session)) {
-        return { valid: false, error: 'Session expired' };
+        return { valid: false, error: "Session expired" };
     }
     return { valid: true, session };
 }
 function isProtectedApiPath(path) {
     const publicPaths = [
-        '/api/auth/sign-in',
-        '/api/auth/session',
-        '/api/auth/logout',
-        '/api/auth/verify',
-        '/api/auth/oauth',
-        '/api/health',
+        "/api/auth/sign-in",
+        "/api/auth/session",
+        "/api/auth/logout",
+        "/api/auth/verify",
+        "/api/auth/oauth",
+        "/api/health",
     ];
     return !publicPaths.some((p) => path.startsWith(p));
 }
 async function handleApiRoute(request, path, config) {
-    const { routeApiRequest } = await import('../routes/api-router.js');
+    const { routeApiRequest } = await import("../routes/api-router.js");
     try {
         const result = await routeApiRequest({
             path: path,
@@ -239,18 +239,18 @@ async function handleApiRoute(request, path, config) {
             headers: request.headers,
             body: request.body,
             auth: config.auth,
-            basePath: config.basePath || '/api/studio',
+            basePath: config.basePath || "/api/studio",
             accessConfig: config.access,
             studioConfig: config,
         });
-        const headers = { 'Content-Type': 'application/json' };
+        const headers = { "Content-Type": "application/json" };
         if (result.cookies && result.cookies.length > 0) {
             const cookieStrings = result.cookies.map((c) => {
                 let cookie = `${c.name}=${c.value}`;
                 if (c.options.httpOnly)
-                    cookie += '; HttpOnly';
+                    cookie += "; HttpOnly";
                 if (c.options.secure)
-                    cookie += '; Secure';
+                    cookie += "; Secure";
                 if (c.options.sameSite)
                     cookie += `; SameSite=${c.options.sameSite}`;
                 if (c.options.maxAge !== undefined)
@@ -259,7 +259,7 @@ async function handleApiRoute(request, path, config) {
                     cookie += `; Path=${c.options.path}`;
                 return cookie;
             });
-            headers['Set-Cookie'] = cookieStrings.join(', ');
+            headers["Set-Cookie"] = cookieStrings.join(", ");
         }
         return {
             status: result.status,
@@ -268,26 +268,26 @@ async function handleApiRoute(request, path, config) {
         };
     }
     catch (error) {
-        console.error('API route error:', error);
-        return jsonResponse(500, { error: 'Internal server error' });
+        console.error("API route error:", error);
+        return jsonResponse(500, { error: "Internal server error" });
     }
 }
 function isNextJsProject() {
     try {
         const cwd = process.cwd();
         // Check for .next directory (build output)
-        if (existsSync(join(cwd, '.next'))) {
+        if (existsSync(join(cwd, ".next"))) {
             return true;
         }
         // Check for next.config.js or next.config.ts
-        if (existsSync(join(cwd, 'next.config.js')) || existsSync(join(cwd, 'next.config.ts'))) {
+        if (existsSync(join(cwd, "next.config.js")) || existsSync(join(cwd, "next.config.ts"))) {
             return true;
         }
         // Check package.json for next dependency
-        const pkgPath = join(cwd, 'package.json');
+        const pkgPath = join(cwd, "package.json");
         if (existsSync(pkgPath)) {
             try {
-                const pkgContent = readFileSync(pkgPath, 'utf-8');
+                const pkgContent = readFileSync(pkgPath, "utf-8");
                 const pkg = JSON.parse(pkgContent);
                 if (pkg.dependencies?.next || pkg.devDependencies?.next) {
                     return true;
@@ -301,14 +301,14 @@ function isNextJsProject() {
 }
 function findPublicDir() {
     const candidates = [];
-    const debug = process.env.VERCEL === '1' || process.env.NODE_ENV === 'production';
+    const debug = process.env.VERCEL === "1" || process.env.NODE_ENV === "production";
     const isNextJs = isNextJsProject();
     // PRIORITY 1: Direct resolution from __dirname (most reliable)
     if (__dirname) {
-        const directPublic = resolve(__dirname, '../public');
+        const directPublic = resolve(__dirname, "../public");
         candidates.unshift(directPublic);
         if (debug && !existsSync(directPublic)) {
-            console.log('[Studio] Direct path not found:', directPublic);
+            console.log("[Studio] Direct path not found:", directPublic);
         }
     }
     // PRIORITY 2: Extract package root from __dirname path (handles pnpm store)
@@ -316,19 +316,19 @@ function findPublicDir() {
         const packageMatch = __dirname.match(/(.+[/\\]better-auth-studio)(?:[/\\]dist[/\\]core)?$/);
         if (packageMatch) {
             const packageRoot = packageMatch[1];
-            candidates.unshift(join(packageRoot, 'dist', 'public'));
+            candidates.unshift(join(packageRoot, "dist", "public"));
         }
     }
     // PRIORITY 3: Walk up from __dirname to find node_modules
     if (__dirname) {
         let searchDir = __dirname;
         for (let i = 0; i < 10; i++) {
-            const nmPath = join(searchDir, 'node_modules', 'better-auth-studio', 'dist', 'public');
+            const nmPath = join(searchDir, "node_modules", "better-auth-studio", "dist", "public");
             if (existsSync(nmPath)) {
                 candidates.unshift(nmPath);
                 break;
             }
-            const parent = resolve(searchDir, '..');
+            const parent = resolve(searchDir, "..");
             if (parent === searchDir)
                 break;
             searchDir = parent;
@@ -340,16 +340,16 @@ function findPublicDir() {
         if (moduleUrl) {
             const modulePath = fileURLToPath(moduleUrl);
             const moduleDir = dirname(modulePath);
-            candidates.push(resolve(moduleDir, '../public'));
+            candidates.push(resolve(moduleDir, "../public"));
             // Also walk up from module location to find node_modules
             let moduleSearchDir = moduleDir;
             for (let i = 0; i < 10; i++) {
-                const nmPath = join(moduleSearchDir, 'node_modules', 'better-auth-studio', 'dist', 'public');
+                const nmPath = join(moduleSearchDir, "node_modules", "better-auth-studio", "dist", "public");
                 if (existsSync(nmPath)) {
                     candidates.push(nmPath);
                     break;
                 }
-                const parent = resolve(moduleSearchDir, '..');
+                const parent = resolve(moduleSearchDir, "..");
                 if (parent === moduleSearchDir)
                     break;
                 moduleSearchDir = parent;
@@ -361,9 +361,9 @@ function findPublicDir() {
     if (isNextJs) {
         try {
             const cwd = process.cwd();
-            const nextServer = join(cwd, '.next', 'server');
+            const nextServer = join(cwd, ".next", "server");
             if (existsSync(nextServer)) {
-                candidates.push(join(nextServer, 'node_modules', 'better-auth-studio', 'dist', 'public'), join(nextServer, 'chunks', 'node_modules', 'better-auth-studio', 'dist', 'public'));
+                candidates.push(join(nextServer, "node_modules", "better-auth-studio", "dist", "public"), join(nextServer, "chunks", "node_modules", "better-auth-studio", "dist", "public"));
             }
         }
         catch (err) {
@@ -373,7 +373,7 @@ function findPublicDir() {
     // PRIORITY 6: Current working directory (all projects)
     try {
         const cwd = process.cwd();
-        candidates.push(join(cwd, 'node_modules', 'better-auth-studio', 'dist', 'public'), join(cwd, 'static', 'studio'));
+        candidates.push(join(cwd, "node_modules", "better-auth-studio", "dist", "public"), join(cwd, "static", "studio"));
     }
     catch (err) { }
     // Validate candidates
@@ -382,10 +382,10 @@ function findPublicDir() {
             if (existsSync(candidate)) {
                 const stats = statSync(candidate);
                 if (stats.isDirectory()) {
-                    const indexPath = join(candidate, 'index.html');
+                    const indexPath = join(candidate, "index.html");
                     if (existsSync(indexPath)) {
                         if (debug) {
-                            console.log('[Studio] ✓ Found public directory:', candidate);
+                            console.log("[Studio] ✓ Found public directory:", candidate);
                         }
                         return candidate;
                     }
@@ -395,9 +395,9 @@ function findPublicDir() {
         catch (error) { }
     }
     if (debug) {
-        console.error('[Studio] ✗ Could not find public directory');
-        console.error('[Studio] __dirname:', __dirname);
-        console.error('[Studio] Checked', candidates.length, 'candidates');
+        console.error("[Studio] ✗ Could not find public directory");
+        console.error("[Studio] __dirname:", __dirname);
+        console.error("[Studio] Checked", candidates.length, "candidates");
     }
     return null;
 }
@@ -407,12 +407,12 @@ function handleStaticFile(path, config) {
         cachedPublicDir = findPublicDir();
     }
     if (!cachedPublicDir) {
-        if (path === '/' || path === '') {
+        if (path === "/" || path === "") {
             return {
                 status: 503,
                 headers: {
-                    'Content-Type': 'text/html',
-                    'Cache-Control': 'no-cache',
+                    "Content-Type": "text/html",
+                    "Cache-Control": "no-cache",
                 },
                 body: `<!DOCTYPE html>
 <html>
@@ -519,15 +519,15 @@ function handleStaticFile(path, config) {
             };
         }
         return jsonResponse(503, {
-            error: 'Public directory not found',
-            message: 'Studio UI assets could not be located. This is likely a Vercel bundling issue.',
-            suggestion: 'For Next.js, add outputFileTracingIncludes to next.config.js to include the public directory. See the HTML error page for details.',
+            error: "Public directory not found",
+            message: "Studio UI assets could not be located. This is likely a Vercel bundling issue.",
+            suggestion: "For Next.js, add outputFileTracingIncludes to next.config.js to include the public directory. See the HTML error page for details.",
         });
     }
     return handleStaticFileFromDir(path, cachedPublicDir, config);
 }
 function handleStaticFileFromDir(path, publicDir, config) {
-    if (path === '/' || path === '') {
+    if (path === "/" || path === "") {
         return serveIndexHtml(publicDir, config);
     }
     const filePath = join(publicDir, path);
@@ -537,8 +537,8 @@ function handleStaticFileFromDir(path, publicDir, config) {
         return {
             status: 200,
             headers: {
-                'Content-Type': contentType,
-                'Cache-Control': getCacheControl(path),
+                "Content-Type": contentType,
+                "Cache-Control": getCacheControl(path),
             },
             body: content,
         };
@@ -550,8 +550,8 @@ function serveIndexHtml(publicDir, config) {
     return {
         status: 200,
         headers: {
-            'Content-Type': 'text/html',
-            'Cache-Control': 'no-cache',
+            "Content-Type": "text/html",
+            "Cache-Control": "no-cache",
         },
         body: html,
     };
@@ -559,31 +559,31 @@ function serveIndexHtml(publicDir, config) {
 function jsonResponse(status, data) {
     return {
         status,
-        headers: { 'Content-Type': 'application/json' },
+        headers: { "Content-Type": "application/json" },
         body: JSON.stringify(data),
     };
 }
 function getContentType(ext) {
     const types = {
-        '.html': 'text/html',
-        '.js': 'application/javascript',
-        '.css': 'text/css',
-        '.json': 'application/json',
-        '.png': 'image/png',
-        '.jpg': 'image/jpeg',
-        '.jpeg': 'image/jpeg',
-        '.svg': 'image/svg+xml',
-        '.ico': 'image/x-icon',
-        '.woff': 'font/woff',
-        '.woff2': 'font/woff2',
-        '.ttf': 'font/ttf',
+        ".html": "text/html",
+        ".js": "application/javascript",
+        ".css": "text/css",
+        ".json": "application/json",
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".svg": "image/svg+xml",
+        ".ico": "image/x-icon",
+        ".woff": "font/woff",
+        ".woff2": "font/woff2",
+        ".ttf": "font/ttf",
     };
-    return types[ext] || 'application/octet-stream';
+    return types[ext] || "application/octet-stream";
 }
 function getCacheControl(path) {
     if (path.match(/\.(js|css|png|jpg|jpeg|svg|woff|woff2|ttf)$/)) {
-        return 'public, max-age=31536000, immutable';
+        return "public, max-age=31536000, immutable";
     }
-    return 'no-cache';
+    return "no-cache";
 }
 //# sourceMappingURL=handler.js.map

package/dist/data.d.ts

@@ -1,4 +1,4 @@
-import type { AuthConfig } from './config.js';
+import type { AuthConfig } from "./config.js";
 export interface User {
     id: string;
     email?: string;
@@ -34,5 +34,5 @@ export interface PaginatedResult<T> {
     limit: number;
     totalPages: number;
 }
-export declare function getAuthData(_authConfig: AuthConfig, type?: 'stats' | 'users' | 'sessions' | 'providers' | 'deleteUser' | 'updateUser' | 'analytics', options?: any, configPath?: string, preloadedAdapter?: any): Promise<any>;
+export declare function getAuthData(_authConfig: AuthConfig, type?: "stats" | "users" | "sessions" | "providers" | "deleteUser" | "updateUser" | "analytics", options?: any, configPath?: string, preloadedAdapter?: any): Promise<any>;
 //# sourceMappingURL=data.d.ts.map