better-auth-studio 1.0.58 → 1.0.59-beta.10

package/dist/routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAOA,OAAO,EAA+B,MAAM,EAAE,MAAM,SAAS,CAAC;AAS9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA8D9C,wBAAsB,oBAAoB,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,UAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,CAyLhG;AAwBD,wBAAgB,YAAY,CAC1B,UAAU,EAAE,UAAU,EACtB,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CAk8KR"}
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAeA,OAAO,EAA+B,MAAM,EAAE,MAAM,SAAS,CAAC;AAS9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA+D9C,wBAAsB,oBAAoB,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,UAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,CAqLhG;AAeD,wBAAgB,YAAY,CAC1B,UAAU,EAAE,UAAU,EACtB,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CA4mLR"}

package/dist/routes.js

@@ -1,5 +1,5 @@
 import { createHmac, randomBytes } from 'node:crypto';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 // @ts-expect-error
@@ -8,6 +8,7 @@ import { scryptAsync } from '@noble/hashes/scrypt.js';
 import { Router } from 'express';
 import { createJiti } from 'jiti';
 import { createMockAccount, createMockSession, createMockUser, createMockVerification, getAuthAdapter, } from './auth-adapter.js';
+import { possiblePaths } from './config.js';
 import { getAuthData } from './data.js';
 import { initializeGeoService, resolveIPLocation, setGeoDbPath } from './geo-service.js';
 import { detectDatabaseWithDialect } from './utils/database-detection.js';
@@ -66,7 +67,6 @@ export async function safeImportAuthConfig(authConfigPath, noCache = false) {
         if (authConfigPath.endsWith('.ts')) {
             const aliases = {};
             const authConfigDir = dirname(authConfigPath);
-            // Find project root by looking for tsconfig.json
             let projectDir = authConfigDir;
             let tsconfigPath = join(projectDir, 'tsconfig.json');
             while (!existsSync(tsconfigPath) && projectDir !== dirname(projectDir)) {
@@ -74,10 +74,8 @@ export async function safeImportAuthConfig(authConfigPath, noCache = false) {
                 tsconfigPath = join(projectDir, 'tsconfig.json');
             }
             const content = readFileSync(authConfigPath, 'utf-8');
-            // Get path aliases from tsconfig (including extends chain)
             const { getPathAliases } = await import('./config.js');
             const tsconfigAliases = getPathAliases(projectDir) || {};
-            // Handle relative imports
             const relativeImportRegex = /import\s+.*?\s+from\s+['"](\.\/[^'"]+)['"]/g;
             const dynamicImportRegex = /import\s*\(\s*['"](\.\/[^'"]+)['"]\s*\)/g;
             const foundImports = new Set();
@@ -111,7 +109,6 @@ export async function safeImportAuthConfig(authConfigPath, noCache = false) {
             const pathAliasRegex = /import\s+.*?\s+from\s+['"](\$[^'"]+)['"]/g;
             while ((match = pathAliasRegex.exec(content)) !== null) {
                 const aliasPath = match[1];
-                // Check if we have a matching alias
                 const aliasBase = aliasPath.split('/')[0];
                 if (tsconfigAliases[aliasBase]) {
                     const remainingPath = aliasPath.replace(aliasBase, '').replace(/^\//, '');
@@ -222,14 +219,6 @@ export async function safeImportAuthConfig(authConfigPath, noCache = false) {
 async function findAuthConfigPath() {
     const { join, dirname } = await import('node:path');
     const { existsSync } = await import('node:fs');
-    const possiblePaths = [
-        'auth.js',
-        'auth.ts',
-        'src/auth.js',
-        'src/auth.ts',
-        'lib/auth.js',
-        'lib/auth.ts',
-    ];
     for (const path of possiblePaths) {
         const fullPath = join(process.cwd(), path);
         if (existsSync(fullPath)) {
@@ -4354,15 +4343,44 @@ export function createRoutes(authConfig, configPath, geoDbPath) {
                     const fields = table.fields
                         ?.filter((f) => f.name.trim())
                         .map((field) => {
-                        let attrStr = `type: "${field.type}"`;
-                        if (field.required)
-                            attrStr += ',\n            required: true';
-                        if (field.unique)
-                            attrStr += ',\n            unique: true';
+                        const attrs = [`type: "${field.type}"`];
+                        attrs.push(`required: ${field.required ? 'true' : 'false'}`);
+                        attrs.push(`unique: ${field.unique ? 'true' : 'false'}`);
+                        attrs.push('input: false');
+                        // Handle defaultValue
+                        if (field.defaultValue !== undefined &&
+                            field.defaultValue !== null &&
+                            field.defaultValue !== '') {
+                            if (field.type === 'string') {
+                                attrs.push(`defaultValue: "${field.defaultValue}"`);
+                            }
+                            else if (field.type === 'boolean') {
+                                attrs.push(`defaultValue: ${field.defaultValue === 'true' || field.defaultValue === true}`);
+                            }
+                            else if (field.type === 'number') {
+                                attrs.push(`defaultValue: ${field.defaultValue}`);
+                            }
+                            else if (field.type === 'date') {
+                                if (field.defaultValue === 'now()') {
+                                    attrs.push('defaultValue: new Date()');
+                                }
+                                else {
+                                    attrs.push(`defaultValue: new Date("${field.defaultValue}")`);
+                                }
+                            }
+                        }
+                        else if (field.type === 'boolean') {
+                            // Default to false for boolean if no defaultValue specified
+                            attrs.push('defaultValue: false');
+                        }
+                        const attrStr = attrs.join(',\n            ');
                         return `          ${field.name}: {\n            ${attrStr}\n          }`;
                     })
                         .join(',\n') || '';
-                    return `      ${table.name}: {
+                    const tableName = table.isExtending && table.extendedTableName
+                        ? table.extendedTableName.trim()
+                        : table.name.trim();
+                    return `      ${tableName}: {
         fields: {
 ${fields}
         },
@@ -4370,7 +4388,29 @@ ${fields}
                 })
                     .join(',\n')
                 : '';
-            // Generate hooks
+            const preserveIndentation = (code, baseIndent) => {
+                if (!code.trim())
+                    return '';
+                const lines = code.split('\n');
+                const nonEmptyLines = lines.filter((line) => line.trim());
+                if (nonEmptyLines.length === 0)
+                    return '';
+                const minIndent = Math.min(...nonEmptyLines.map((line) => {
+                    const match = line.match(/^(\s*)/);
+                    return match ? match[1].length : 0;
+                }));
+                return lines
+                    .map((line) => {
+                    if (!line.trim())
+                        return '';
+                    const currentIndent = line.match(/^(\s*)/)?.[1] || '';
+                    const relativeIndent = Math.max(0, currentIndent.length - minIndent);
+                    const content = line.trim();
+                    return baseIndent + ' '.repeat(relativeIndent) + content;
+                })
+                    .filter(Boolean)
+                    .join('\n');
+            };
             const beforeHooks = hooks
                 .filter((h) => h.timing === 'before')
                 .map((hook) => {
@@ -4390,11 +4430,11 @@ ${fields}
                 else {
                     matcher = `(ctx) => true`;
                 }
+                const formattedHookLogic = preserveIndentation(hook.hookLogic || '// Hook logic here', '            ');
                 return `        {
           matcher: ${matcher},
           handler: createAuthMiddleware(async (ctx) => {
-            // ${hook.name || `${hook.timing} ${hook.action} hook`}
-            ${hook.hookLogic || '// Hook logic here'}
+${formattedHookLogic}
           }),
         }`;
             });
@@ -4417,27 +4457,25 @@ ${fields}
                 else {
                     matcher = `(ctx) => true`;
                 }
+                const formattedHookLogic = preserveIndentation(hook.hookLogic || '// Hook logic here', '            ');
                 return `        {
           matcher: ${matcher},
           handler: createAuthMiddleware(async (ctx) => {
-            // ${hook.name || `${hook.timing} ${hook.action} hook`}
-            ${hook.hookLogic || '// Hook logic here'}
+${formattedHookLogic}
           }),
         }`;
             });
-            // Generate middleware
             const middlewareCode = middleware
                 .map((mw) => {
+                const formattedMiddlewareLogic = preserveIndentation(mw.middlewareLogic || '// Middleware logic here', '          ');
                 return `      {
         path: "${mw.path}",
         middleware: createAuthMiddleware(async (ctx) => {
-          // ${mw.name || 'Middleware'}
-          ${mw.middlewareLogic || '// Middleware logic here'}
+${formattedMiddlewareLogic}
         }),
       }`;
             })
                 .join(',\n');
-            // Generate endpoints
             const endpointsCode = endpoints.length > 0
                 ? endpoints
                     .map((endpoint) => {
@@ -4445,27 +4483,14 @@ ${fields}
                     const sanitizedName = endpointName.replace(/[^a-zA-Z0-9]/g, '');
                     const endpointPath = endpoint.path?.trim() || `/${camelCaseName}/${sanitizedName}`;
                     const handlerLogic = endpoint.handlerLogic ||
-                        '// Endpoint handler logic here\n          return ctx.json({ success: true });';
-                    const formattedHandlerLogic = handlerLogic
-                        .split('\n')
-                        .map((line) => {
-                        const trimmed = line.trim();
-                        if (!trimmed)
-                            return '';
-                        if (!line.startsWith('          ')) {
-                            return '          ' + trimmed;
-                        }
-                        return line;
-                    })
-                        .filter(Boolean)
-                        .join('\n');
+                        '// Endpoint handler logic here\nreturn ctx.json({ success: true });';
+                    const formattedHandlerLogic = preserveIndentation(handlerLogic, '          ');
                     return `      ${sanitizedName}: createAuthEndpoint(
         "${endpointPath}",
         {
-          method: "${endpoint.method || 'POST'}" as const,
+          method: "${endpoint.method || 'POST'}",
         },
         async (ctx) => {
-          // ${endpoint.name || sanitizedName}
 ${formattedHandlerLogic}
         },
       ),`;
@@ -4531,14 +4556,13 @@ ${formattedHandlerLogic}
             if (rateLimitCode) {
                 pluginParts.push(`    rateLimit: {\n${rateLimitCode}\n    }`);
             }
-            // Generate server plugin code
             const imports = ['import type { BetterAuthPlugin } from "@better-auth/core"'];
             if (hooks.length > 0 || middleware.length > 0 || endpoints.length > 0) {
                 imports.push('import { createAuthEndpoint, createAuthMiddleware } from "@better-auth/core/api"');
             }
             const serverPluginBody = pluginParts.length > 0
-                ? `    id: "${camelCaseName}" as const,\n${pluginParts.join(',\n')}`
-                : `    id: "${camelCaseName}" as const`;
+                ? `    id: "${camelCaseName}",\n${pluginParts.join(',\n')}`
+                : `    id: "${camelCaseName}"`;
             const serverPluginCode = cleanCode(`import type { BetterAuthPlugin } from "@better-auth/core";
 ${imports.join('\n')}
 
@@ -4578,12 +4602,11 @@ import type { ${camelCaseName} } from "..";
 
 export const ${camelCaseName}Client = () => {
   return {
-    id: "${camelCaseName}" as const,
+    id: "${camelCaseName}",
     $InferServerPlugin: {} as ReturnType<typeof ${camelCaseName}>,${pathMethods ? `\n    pathMethods: {\n${pathMethods}\n    },` : ''}${atomListenersCode}
   } satisfies BetterAuthClientPlugin;
 };
 `);
-            // Generate server setup code
             const serverSetupCode = cleanCode(`import { betterAuth } from "@better-auth/core";
 import { ${camelCaseName} } from "./plugin/${camelCaseName}";
 
@@ -4601,7 +4624,6 @@ export const auth = betterAuth({
                 vue: 'better-auth/vue',
             };
             const frameworkImport = frameworkImportMap[clientFramework] || 'better-auth/react';
-            // Get baseURL based on framework
             const baseURLMap = {
                 react: 'process.env.NEXT_PUBLIC_BETTER_AUTH_URL || "http://localhost:3000"',
                 svelte: 'import.meta.env.PUBLIC_BETTER_AUTH_URL || "http://localhost:5173"',
@@ -4985,6 +5007,110 @@ export const authClient = createAuthClient({
             });
         }
     });
+    router.post('/api/tools/check-env-secret', async (_req, res) => {
+        try {
+            const envPath = join(process.cwd(), '.env');
+            const envLocalPath = join(process.cwd(), '.env.local');
+            const targetPath = existsSync(envLocalPath) ? envLocalPath : envPath;
+            const envContent = existsSync(targetPath) ? readFileSync(targetPath, 'utf-8') : '';
+            const envLines = envContent.split('\n');
+            let existingSecret;
+            envLines.forEach((line) => {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#'))
+                    return;
+                const match = trimmed.match(/^BETTER_AUTH_SECRET\s*=\s*(.*)$/i);
+                if (match) {
+                    let value = match[1].trim();
+                    if (value.length >= 2) {
+                        if ((value.startsWith('"') && value.endsWith('"')) ||
+                            (value.startsWith("'") && value.endsWith("'"))) {
+                            value = value.slice(1, -1).trim();
+                        }
+                    }
+                    if (value && value.trim() !== '') {
+                        existingSecret = value;
+                    }
+                }
+            });
+            const hasExisting = !!existingSecret && existingSecret.trim() !== '';
+            res.json({
+                success: true,
+                hasExisting,
+                existingSecret: hasExisting ? existingSecret : undefined,
+                path: targetPath,
+            });
+        }
+        catch (error) {
+            res.status(500).json({
+                success: false,
+                message: error instanceof Error ? error.message : 'Failed to check secret',
+            });
+        }
+    });
+    router.post('/api/tools/write-env-secret', async (req, res) => {
+        try {
+            const { secret, action = 'override' } = req.body || {};
+            if (!secret) {
+                return res.status(400).json({
+                    success: false,
+                    message: 'Secret is required',
+                });
+            }
+            const envPath = join(process.cwd(), '.env');
+            const envLocalPath = join(process.cwd(), '.env.local');
+            const targetPath = existsSync(envLocalPath) ? envLocalPath : envPath;
+            const envContent = existsSync(targetPath) ? readFileSync(targetPath, 'utf-8') : '';
+            const envLines = envContent.split('\n');
+            const envMap = new Map();
+            const newLines = [];
+            envLines.forEach((line, index) => {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#')) {
+                    newLines.push(line);
+                    return;
+                }
+                const match = trimmed.match(/^([^=#]+)\s*=\s*(.*)$/);
+                if (match) {
+                    const key = match[1].trim();
+                    if (key.toUpperCase() === 'BETTER_AUTH_SECRET') {
+                        envMap.set('BETTER_AUTH_SECRET', { line, index });
+                        if (action === 'override') {
+                            newLines.push(`BETTER_AUTH_SECRET=${secret}`);
+                        }
+                        else {
+                            newLines.push(line);
+                        }
+                    }
+                    else {
+                        newLines.push(line);
+                    }
+                }
+                else {
+                    newLines.push(line);
+                }
+            });
+            if (!envMap.has('BETTER_AUTH_SECRET')) {
+                if (newLines.length > 0 && newLines[newLines.length - 1].trim() !== '') {
+                    newLines.push('');
+                }
+                newLines.push(`BETTER_AUTH_SECRET=${secret}`);
+            }
+            const newContent = newLines.join('\n');
+            writeFileSync(targetPath, newContent, 'utf-8');
+            res.json({
+                success: true,
+                message: 'Secret written successfully',
+                path: targetPath,
+            });
+        }
+        catch (error) {
+            res.status(500).json({
+                success: false,
+                message: error instanceof Error ? error.message : 'Failed to write secret to .env',
+            });
+        }
+    });
     router.post('/api/tools/check-env-credentials', async (req, res) => {
         try {
             const { provider } = req.body || {};