better-auth-studio 1.0.79-beta.3 → 1.0.79-beta.30

package/dist/routes.js

@@ -1,6 +1,7 @@
 import { createHmac, randomBytes } from 'node:crypto';
 import { existsSync, readFileSync, writeFileSync, } from 'node:fs';
 import { dirname, join } from 'node:path';
+import { createRequire } from 'module';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 // @ts-expect-error
 import { hex } from '@better-auth/utils/hex';
@@ -57,8 +58,24 @@ function getStudioVersion() {
             const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
             return packageJson.version || '1.0.0';
         }
+        const nodeModulesPath = join(process.cwd(), 'node_modules/better-auth-studio/package.json');
+        if (existsSync(nodeModulesPath)) {
+            const packageJson = JSON.parse(readFileSync(nodeModulesPath, 'utf-8'));
+            return packageJson.version || '1.0.0';
+        }
+        try {
+            const require = createRequire(import.meta.url);
+            const resolvedPath = require.resolve('better-auth-studio/package.json');
+            if (existsSync(resolvedPath)) {
+                const packageJson = JSON.parse(readFileSync(resolvedPath, 'utf-8'));
+                return packageJson.version || '1.0.0';
+            }
+        }
+        catch (_resolveError) {
+        }
+    }
+    catch (_error) {
     }
-    catch (_error) { }
     return '1.0.0';
 }
 function _resolveModuleWithExtensions(id, parent) {
@@ -252,7 +269,10 @@ async function findAuthConfigPath() {
 export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter, preloadedAuthOptions, accessConfig, authInstance) {
     const isSelfHosted = !!preloadedAdapter;
     const getAuthConfigSafe = async () => {
-        if (isSelfHosted && preloadedAuthOptions) {
+        if (isSelfHosted) {
+            return preloadedAuthOptions || authConfig || null;
+        }
+        if (preloadedAuthOptions) {
             return preloadedAuthOptions;
         }
         try {
@@ -270,7 +290,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
         catch (_error) {
             // Ignors errors
         }
-        return null;
+        return authConfig || null;
     };
     const router = Router();
     const base64UrlEncode = (value) => Buffer.from(value)
@@ -476,7 +496,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             if (!email || !password) {
                 return res.status(400).json({ success: false, message: 'Email and password required' });
             }
-            const adapter = await getAuthAdapter();
+            const adapter = await getAuthAdapterWithConfig();
             let signInResult = null;
             let signInError = null;
             try {
@@ -517,7 +537,6 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
                             message: 'Password not configured. Please reset your password.',
                         });
                     }
-                    console.log({ users, credentialAccount });
                     const isValidPassword = await verifyPassword(password, credentialAccount.password);
                     if (!isValidPassword) {
                         return res.status(401).json({ success: false, message: 'Invalid credentials' });
@@ -528,7 +547,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
                     if (!allowedRoles.includes(user.role)) {
                         return res.status(403).json({
                             success: false,
-                            message: `Access denied. Required role: ${allowedRoles.join(' or ')}`,
+                            message: `Access denied.`,
                             userRole: user.role || 'none',
                         });
                     }
@@ -577,7 +596,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             if (!allowedRoles.includes(user.role)) {
                 return res.status(403).json({
                     success: false,
-                    message: `Access denied. Required role: ${allowedRoles.join(' or ')}`,
+                    message: `Access denied.`,
                     userRole: user.role || 'none',
                 });
             }
@@ -807,6 +826,21 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             }
         }
         catch (_error) { }
+        // Get studio version - always fetch from npm registry for latest version
+        let studioVersion = '1.0.0';
+        try {
+            const response = await fetch('https://registry.npmjs.org/better-auth-studio/latest', {
+                signal: AbortSignal.timeout(2000), // 2 second timeout
+            });
+            if (response.ok) {
+                const data = (await response.json());
+                studioVersion = data.version || '1.0.0';
+            }
+        }
+        catch (_npmError) {
+            // Fallback to local version if npm fetch fails
+            studioVersion = getStudioVersion();
+        }
         if (databaseType === 'unknown' && !isSelfHosted) {
             const authConfigPath = configPath || (await findAuthConfigPath());
             if (authConfigPath) {
@@ -883,7 +917,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             disabledPaths: effectiveConfig.disabledPaths || [],
             telemetry: effectiveConfig.telemetry,
             studio: {
-                version: getStudioVersion(),
+                version: studioVersion,
                 nodeVersion: process.version,
                 platform: process.platform,
                 uptime: process.uptime(),
@@ -893,7 +927,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.get('/api/stats', async (_req, res) => {
         try {
-            const stats = await getAuthData(authConfig, 'stats', undefined, configPath);
+            const stats = await getAuthData(authConfig, 'stats', undefined, configPath, preloadedAdapter);
             res.json(stats);
         }
         catch (_error) {
@@ -908,7 +942,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
                 type: type,
                 from: from,
                 to: to,
-            }, configPath);
+            }, configPath, preloadedAdapter);
             res.json(analytics);
         }
         catch (_error) {
@@ -925,26 +959,17 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             let organizationPluginEnabled = false;
             let teamsPluginEnabled = false;
             try {
-                let betterAuthConfig = preloadedAuthOptions;
-                if (!betterAuthConfig && !isSelfHosted) {
-                    const authConfigPath = configPath || (await findAuthConfigPath());
-                    if (authConfigPath) {
-                        const { getConfig } = await import('./config.js');
-                        betterAuthConfig = await getConfig({
-                            cwd: process.cwd(),
-                            configPath: authConfigPath,
-                            shouldThrowOnError: false,
-                            noCache: true, // Disable cache for real-time plugin checks
-                        });
-                    }
-                }
+                const betterAuthConfig = preloadedAuthOptions || (await getAuthConfigSafe());
                 if (betterAuthConfig) {
                     const plugins = betterAuthConfig.plugins || [];
                     const organizationPlugin = plugins.find((plugin) => plugin.id === 'organization');
                     organizationPluginEnabled = !!organizationPlugin;
-                    teamsPluginEnabled = !!organizationPlugin?.options?.teams?.enabled;
                     if (organizationPlugin) {
-                        teamsPluginEnabled = organizationPlugin.options?.teams?.enabled === true;
+                        teamsPluginEnabled =
+                            organizationPlugin.options?.teams?.enabled === true ||
+                                organizationPlugin.teams?.enabled === true ||
+                                organizationPlugin.config?.teams?.enabled === true ||
+                                false;
                     }
                 }
             }
@@ -1471,7 +1496,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
                 }
             }
             catch (_adapterError) { }
-            const result = await getAuthData(authConfig, 'users', { page, limit, search }, configPath);
+            const result = await getAuthData(authConfig, 'users', { page, limit, search }, configPath, preloadedAdapter);
             const transformedUsers = (result.data || []).map((user) => ({
                 id: user.id,
                 email: user.email,
@@ -1496,7 +1521,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
         try {
             const page = parseInt(req.query.page, 10) || 1;
             const limit = parseInt(req.query.limit, 10) || 20;
-            const sessions = await getAuthData(authConfig, 'sessions', { page, limit }, configPath);
+            const sessions = await getAuthData(authConfig, 'sessions', { page, limit }, configPath, preloadedAdapter);
             res.json(sessions);
         }
         catch (_error) {
@@ -1505,7 +1530,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.get('/api/providers', async (_req, res) => {
         try {
-            const providers = await getAuthData(authConfig, 'providers', undefined, configPath);
+            const providers = await getAuthData(authConfig, 'providers', undefined, configPath, preloadedAdapter);
             res.json(providers);
         }
         catch (_error) {
@@ -1515,7 +1540,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     router.delete('/api/users/:id', async (req, res) => {
         try {
             const { id } = req.params;
-            await getAuthData(authConfig, 'deleteUser', { id }, configPath);
+            await getAuthData(authConfig, 'deleteUser', { id }, configPath, preloadedAdapter);
             res.json({ success: true });
         }
         catch (_error) {
@@ -1524,60 +1549,82 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.get('/api/plugins', async (_req, res) => {
         try {
-            const authConfigPath = configPath
-                ? join(process.cwd(), configPath)
-                : await findAuthConfigPath();
-            if (!authConfigPath) {
+            const betterAuthConfig = preloadedAuthOptions || (await getAuthConfigSafe());
+            if (betterAuthConfig) {
+                const plugins = betterAuthConfig.plugins || [];
+                const pluginInfo = plugins.map((plugin) => ({
+                    id: plugin.id,
+                    name: plugin.name || plugin.id,
+                    description: plugin.description || `${plugin.id} plugin for Better Auth`,
+                    enabled: true,
+                }));
                 return res.json({
-                    plugins: [],
-                    error: 'No auth config found',
-                    configPath: null,
+                    plugins: pluginInfo,
+                    configPath: isSelfHosted ? null : configPath || null,
+                    totalPlugins: pluginInfo.length,
                 });
             }
-            try {
-                let authModule;
-                try {
-                    authModule = await safeImportAuthConfig(authConfigPath, true); // Disable cache for real-time plugin checks
+            if (!isSelfHosted) {
+                const authConfigPath = configPath
+                    ? join(process.cwd(), configPath)
+                    : await findAuthConfigPath();
+                if (!authConfigPath) {
+                    return res.json({
+                        plugins: [],
+                        error: 'No auth config found',
+                        configPath: null,
+                    });
                 }
-                catch (_importError) {
-                    const content = readFileSync(authConfigPath, 'utf-8');
-                    authModule = {
-                        auth: {
-                            options: {
-                                _content: content,
-                                plugins: [],
+                try {
+                    let authModule;
+                    try {
+                        authModule = await safeImportAuthConfig(authConfigPath, true); // Disable cache for real-time plugin checks
+                    }
+                    catch (_importError) {
+                        const content = readFileSync(authConfigPath, 'utf-8');
+                        authModule = {
+                            auth: {
+                                options: {
+                                    _content: content,
+                                    plugins: [],
+                                },
                             },
-                        },
-                    };
+                        };
+                    }
+                    const auth = authModule.auth || authModule.default;
+                    if (!auth) {
+                        return res.json({
+                            plugins: [],
+                            error: 'No auth export found',
+                            configPath: authConfigPath,
+                        });
+                    }
+                    const plugins = auth.options?.plugins || [];
+                    const pluginInfo = plugins.map((plugin) => ({
+                        id: plugin.id,
+                        name: plugin.name || plugin.id,
+                        description: plugin.description || `${plugin.id} plugin for Better Auth`,
+                        enabled: true,
+                    }));
+                    return res.json({
+                        plugins: pluginInfo,
+                        configPath: authConfigPath,
+                        totalPlugins: pluginInfo.length,
+                    });
                 }
-                const auth = authModule.auth || authModule.default;
-                if (!auth) {
+                catch (_error) {
                     return res.json({
                         plugins: [],
-                        error: 'No auth export found',
+                        error: 'Failed to load auth config - import failed and regex extraction unavailable',
                         configPath: authConfigPath,
                     });
                 }
-                const plugins = auth.options?.plugins || [];
-                const pluginInfo = plugins.map((plugin) => ({
-                    id: plugin.id,
-                    name: plugin.name || plugin.id,
-                    description: plugin.description || `${plugin.id} plugin for Better Auth`,
-                    enabled: true,
-                }));
-                res.json({
-                    plugins: pluginInfo,
-                    configPath: authConfigPath,
-                    totalPlugins: pluginInfo.length,
-                });
-            }
-            catch (_error) {
-                res.json({
-                    plugins: [],
-                    error: 'Failed to load auth config - import failed and regex extraction unavailable',
-                    configPath: authConfigPath,
-                });
             }
+            return res.json({
+                plugins: [],
+                error: 'No auth config found',
+                configPath: null,
+            });
         }
         catch (_error) {
             res.status(500).json({ error: 'Failed to fetch plugins' });
@@ -1585,6 +1632,13 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.get('/api/database/info', async (_req, res) => {
         try {
+            if (isSelfHosted && preloadedAuthOptions) {
+                const database = preloadedAuthOptions.database;
+                return res.json({
+                    database: database,
+                    configPath: null,
+                });
+            }
             const authConfigPath = configPath || (await findAuthConfigPath());
             if (!authConfigPath) {
                 return res.json({
@@ -1978,7 +2032,6 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             });
         }
     });
-    // Database Detection endpoint - Auto-detect database from installed packages
     router.get('/api/database/detect', async (_req, res) => {
         try {
             const detectedDb = await detectDatabaseWithDialect();
@@ -2047,7 +2100,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.post('/api/admin/ban-user', async (req, res) => {
         try {
-            const auth = await getAuthConfigSafe();
+            const auth = preloadedAuthOptions || (await getAuthConfigSafe());
             if (!auth) {
                 return res.status(400).json({
                     success: false,
@@ -2086,7 +2139,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.post('/api/admin/unban-user', async (req, res) => {
         try {
-            const auth = await getAuthConfigSafe();
+            const auth = preloadedAuthOptions || (await getAuthConfigSafe());
             if (!auth) {
                 return res.status(400).json({
                     success: false,
@@ -2125,7 +2178,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.get('/api/admin/status', async (_req, res) => {
         try {
-            const betterAuthConfig = await getAuthConfigSafe();
+            const betterAuthConfig = preloadedAuthOptions || (await getAuthConfigSafe());
             if (!betterAuthConfig) {
                 return res.json({
                     enabled: false,
@@ -2149,8 +2202,6 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             });
         }
     });
-    // Database Schema Visualization endpoint
-    // Now uses loadContextTables to dynamically load schema from Better Auth context
     const CONTEXT_CORE_TABLES = new Set(['user', 'session', 'account', 'verification']);
     async function resolveSchemaConfigPath() {
         if (configPath) {
@@ -2160,16 +2211,23 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     }
     async function loadContextTables() {
         try {
+            if (isSelfHosted && authInstance?.$context) {
+                try {
+                    const context = await authInstance.$context;
+                    return context?.tables || null;
+                }
+                catch (_error) { }
+            }
             const authConfigPath = await resolveSchemaConfigPath();
             if (!authConfigPath) {
                 return null;
             }
             const authModule = await safeImportAuthConfig(authConfigPath);
-            const authInstance = authModule?.auth || authModule?.default;
-            if (!authInstance?.$context) {
+            const fileAuthInstance = authModule?.auth || authModule?.default;
+            if (!fileAuthInstance?.$context) {
                 return null;
             }
-            const context = await authInstance.$context;
+            const context = await fileAuthInstance.$context;
             return context?.tables || null;
         }
         catch (_error) {
@@ -2293,14 +2351,11 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             if (!schema) {
                 return null;
             }
-            // Filter by plugin origin if plugins are specified
             if (selectedPlugins && selectedPlugins.length > 0) {
                 schema.tables = schema.tables.filter((table) => {
-                    // Include core tables
                     if (CONTEXT_CORE_TABLES.has(table.name)) {
                         return true;
                     }
-                    // Include tables from selected plugins
                     return selectedPlugins.includes(table.origin);
                 });
             }
@@ -2352,28 +2407,46 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.get('/api/plugins/teams/status', async (_req, res) => {
         try {
-            const betterAuthConfig = await getAuthConfigSafe();
+            const betterAuthConfig = preloadedAuthOptions || (await getAuthConfigSafe());
             if (!betterAuthConfig) {
                 return res.json({
                     enabled: false,
                     error: 'No auth config found',
-                    configPath: null,
+                    configPath: isSelfHosted ? null : configPath || null,
                 });
             }
             const plugins = betterAuthConfig.plugins || [];
             const organizationPlugin = plugins.find((plugin) => plugin.id === 'organization');
             if (organizationPlugin) {
-                const teamsEnabled = organizationPlugin.options?.teams?.enabled === true;
+                let teamsEnabled = false;
+                if (organizationPlugin.options?.teams?.enabled === true) {
+                    teamsEnabled = true;
+                }
+                else if (organizationPlugin.teams?.enabled === true) {
+                    teamsEnabled = true;
+                }
+                else if (organizationPlugin.config?.teams?.enabled === true) {
+                    teamsEnabled = true;
+                }
+                else if (organizationPlugin.options?.teams &&
+                    typeof organizationPlugin.options.teams === 'object') {
+                    teamsEnabled = organizationPlugin.options.teams.enabled === true;
+                }
+                else if (organizationPlugin.teams && typeof organizationPlugin.teams === 'object') {
+                    teamsEnabled = organizationPlugin.teams.enabled === true;
+                }
+                const teamSchema = organizationPlugin.schema;
+                teamsEnabled = 'team' in teamSchema;
                 return res.json({
                     enabled: teamsEnabled,
-                    configPath: configPath || null,
+                    configPath: isSelfHosted ? null : configPath || null,
                     organizationPlugin: organizationPlugin || null,
                 });
             }
             else {
                 return res.json({
                     enabled: false,
-                    configPath: configPath || null,
+                    configPath: isSelfHosted ? null : configPath || null,
                     organizationPlugin: null,
                     error: 'Organization plugin not found',
                 });
@@ -2735,22 +2808,50 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
         try {
             const { orgId } = req.params;
             const adapter = await getAuthAdapterWithConfig();
-            if (adapter && typeof adapter.findMany === 'function') {
+            if (!adapter) {
+                return res.status(500).json({
+                    success: false,
+                    error: 'Auth adapter not available',
+                    teams: [],
+                });
+            }
+            if (typeof adapter.findMany !== 'function') {
+                return res.status(500).json({
+                    success: false,
+                    error: 'Adapter findMany method not available',
+                    teams: [],
+                });
+            }
+            try {
+                let teams = [];
                 try {
-                    const teams = await adapter.findMany({
+                    teams = await adapter.findMany({
                         model: 'team',
                         where: [{ field: 'organizationId', value: orgId }],
                         limit: 10000,
                     });
-                    const transformedTeams = await Promise.all((teams || []).map(async (team) => {
-                        if (!adapter.findMany) {
-                            return null;
+                }
+                catch (whereError) {
+                    const allTeams = await adapter.findMany({
+                        model: 'team',
+                        limit: 10000,
+                    });
+                    teams = (allTeams || []).filter((team) => team.organizationId === orgId);
+                }
+                if (!teams || teams.length === 0) {
+                    return res.json({ success: true, teams: [] });
+                }
+                const transformedTeams = await Promise.all((teams || []).map(async (team) => {
+                    try {
+                        let memberCount = 0;
+                        if (adapter.findMany) {
+                            const teamMembers = await adapter.findMany({
+                                model: 'teamMember',
+                                where: [{ field: 'teamId', value: team.id }],
+                                limit: 10000,
+                            });
+                            memberCount = teamMembers ? teamMembers.length : 0;
                         }
-                        const teamMembers = await adapter.findMany({
-                            model: 'teamMember',
-                            where: [{ field: 'teamId', value: team.id }],
-                            limit: 10000,
-                        });
                         return {
                             id: team.id,
                             name: team.name,
@@ -2758,18 +2859,38 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
                             metadata: team.metadata,
                             createdAt: team.createdAt,
                             updatedAt: team.updatedAt,
-                            memberCount: teamMembers ? teamMembers.length : 0,
+                            memberCount: memberCount,
                         };
-                    }));
-                    res.json({ success: true, teams: transformedTeams });
-                    return;
-                }
-                catch (_error) { }
+                    }
+                    catch (_error) {
+                        return {
+                            id: team.id,
+                            name: team.name,
+                            organizationId: team.organizationId,
+                            metadata: team.metadata,
+                            createdAt: team.createdAt,
+                            updatedAt: team.updatedAt,
+                            memberCount: 0,
+                        };
+                    }
+                }));
+                const validTeams = transformedTeams.filter((team) => team !== null);
+                return res.json({ success: true, teams: validTeams });
+            }
+            catch (error) {
+                return res.json({
+                    success: true,
+                    teams: [],
+                    error: error?.message || 'Failed to fetch teams',
+                });
             }
-            res.json({ success: true, teams: [] });
         }
-        catch (_error) {
-            res.status(500).json({ error: 'Failed to fetch teams' });
+        catch (error) {
+            res.status(500).json({
+                success: false,
+                error: 'Failed to fetch teams',
+                message: error?.message || 'Unknown error',
+            });
         }
     });
     router.post('/api/organizations/:orgId/teams', async (req, res) => {
@@ -2794,7 +2915,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             if (!adapter.create) {
                 return res.status(500).json({ error: 'Adapter create method not available' });
             }
-            await adapter.create({
+            const teamResult = await adapter.create({
                 model: 'team',
                 data: {
                     name: teamData.name,
@@ -2803,6 +2924,9 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
                     updatedAt: teamData.updatedAt,
                 },
             });
+            if (!teamResult) {
+                return res.status(500).json({ error: 'Failed to create team' });
+            }
             res.json({ success: true, team });
         }
         catch (_error) {
@@ -2872,39 +2996,83 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
                 return res.status(400).json({ error: 'userIds array is required' });
             }
             const adapter = await getAuthAdapterWithConfig();
-            if (!adapter || !adapter.create) {
+            if (!adapter) {
                 return res.status(500).json({ error: 'Adapter not available' });
             }
+            if (!adapter.create) {
+                return res.status(500).json({ error: 'Adapter create method not available' });
+            }
             const results = [];
             for (const userId of userIds) {
                 try {
+                    let existingMember = null;
+                    if (adapter.findMany) {
+                        try {
+                            const existing = await adapter.findMany({
+                                model: 'teamMember',
+                                where: [
+                                    { field: 'teamId', value: teamId },
+                                    { field: 'userId', value: userId },
+                                ],
+                                limit: 1,
+                            });
+                            existingMember = existing && existing.length > 0 ? existing[0] : null;
+                        }
+                        catch (_findError) {
+                            // if where clause isn't working.
+                            try {
+                                const allMembers = await adapter.findMany({
+                                    model: 'teamMember',
+                                    limit: 10000,
+                                });
+                                existingMember = (allMembers || []).find((m) => m.teamId === teamId && m.userId === userId);
+                            }
+                            catch (_fallbackError) { }
+                        }
+                    }
+                    if (existingMember) {
+                        results.push({
+                            success: false,
+                            userId,
+                            error: 'User is already a member of this team',
+                        });
+                        continue;
+                    }
+                    const now = new Date();
                     await adapter.create({
                         model: 'teamMember',
                         data: {
                             teamId,
                             userId,
                             role: 'member',
-                            createdAt: new Date(),
+                            createdAt: now,
+                            updatedAt: now,
                         },
                     });
                     results.push({ success: true, userId });
                 }
                 catch (error) {
+                    const errorMessage = error?.message || error?.toString() || 'Unknown error';
                     results.push({
                         success: false,
                         userId,
-                        error: error instanceof Error ? error.message : 'Unknown error',
+                        error: errorMessage,
                     });
                 }
             }
+            const successCount = results.filter((r) => r.success).length;
             res.json({
-                success: true,
-                message: `Added ${results.filter((r) => r.success).length} members`,
+                success: results.some((r) => r.success),
+                message: `Added ${successCount} member${successCount !== 1 ? 's' : ''}`,
                 results,
             });
         }
-        catch (_error) {
-            res.status(500).json({ error: 'Failed to add team members' });
+        catch (error) {
+            res.status(500).json({
+                success: false,
+                error: 'Failed to add team members',
+                message: error?.message || 'Unknown error',
+            });
         }
     });
     router.delete('/api/team-members/:id', async (req, res) => {
@@ -2974,7 +3142,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.get('/api/plugins/organization/status', async (_req, res) => {
         try {
-            const betterAuthConfig = await getAuthConfigSafe();
+            const betterAuthConfig = preloadedAuthOptions || (await getAuthConfigSafe());
             if (!betterAuthConfig) {
                 return res.json({
                     enabled: false,
@@ -3106,7 +3274,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
         try {
             const { id } = req.params;
             const userData = req.body;
-            const updatedUser = await getAuthData(authConfig, 'updateUser', { id, userData }, configPath);
+            const updatedUser = await getAuthData(authConfig, 'updateUser', { id, userData }, configPath, preloadedAdapter);
             res.json({ success: true, user: updatedUser });
         }
         catch (_error) {