@makolabs/ripple 1.2.10 → 1.2.12

package/dist/user-management/adapters/UserManagement.remote.d.ts

@@ -1,75 +1,18 @@
-/**
- * User Management Remote Functions
- *
- * Complete implementation template for user management remote functions.
- * This follows the same pattern as users.remote.ts and is designed to be
- * used as-is in SvelteKit applications like sharkfin-frontend.
- *
- * Configuration:
- * - Set environment variables: CLERK_SECRET_KEY, ADMIN_API_KEY, PRIVATE_BASE_AUTH_URL, ALLOWED_ORG_ID
- * - Configure CLIENT_ID via ADMIN_CONFIG or env variable (CLIENT_ID)
- * - Adjust permission prefix filter via PERMISSION_PREFIX env variable
- *
- * @see https://svelte.dev/docs/kit/remote-functions
- *
- * Usage in your app:
- * ```svelte
- * <script>
- *   import { UserManagement } from '@makolabs/ripple';
- *   import * as adapter from '../UserManagement.remote';
- * </script>
- *
- * <UserManagement adapter={adapter} />
- * ```
- */
 import type { User } from '../user-management.js';
 import type { GetUsersOptions, GetUsersResult } from './types.js';
-/**
- * Get users with pagination and sorting
- *
- * Transforms adapter options to Clerk API format
- */
 export declare const getUsers: import("@sveltejs/kit").RemoteQueryFunction<GetUsersOptions, GetUsersResult>;
-/**
- * Create a new user
- *
- * Creates user in Clerk, optionally adds to organization, and creates admin key with permissions
- */
 export declare const createUser: import("@sveltejs/kit").RemoteCommand<Partial<User>, Promise<User>>;
-/**
- * Update an existing user
- */
 export declare const updateUser: import("@sveltejs/kit").RemoteCommand<{
     userId: string;
     userData: Partial<User>;
 }, Promise<User>>;
-/**
- * Delete a single user
- */
 export declare const deleteUser: import("@sveltejs/kit").RemoteCommand<string, Promise<void>>;
-/**
- * Delete multiple users
- */
 export declare const deleteUsers: import("@sveltejs/kit").RemoteCommand<string[], Promise<void>>;
-/**
- * Get permissions for specific users (batched)
- *
- * Uses 'sub' (userId) parameter in admin API calls.
- * Batches multiple permission requests to avoid n+1 problem.
- */
 export declare const getUserPermissions: import("@sveltejs/kit").RemoteQueryFunction<string, Promise<string[]>>;
-/**
- * Update permissions for a specific user
- *
- * Uses 'sub' (userId) parameter in admin API calls
- */
 export declare const updateUserPermissions: import("@sveltejs/kit").RemoteCommand<{
     userId: string;
     permissions: string[];
 }, Promise<void>>;
-/**
- * Generate new API key for a user with optional old key revocation
- */
 export declare const generateApiKey: import("@sveltejs/kit").RemoteCommand<{
     userId: string;
     permissions: string[];

package/dist/user-management/adapters/UserManagement.remote.js

@@ -1,46 +1,19 @@
-/**
- * User Management Remote Functions
- *
- * Complete implementation template for user management remote functions.
- * This follows the same pattern as users.remote.ts and is designed to be
- * used as-is in SvelteKit applications like sharkfin-frontend.
- *
- * Configuration:
- * - Set environment variables: CLERK_SECRET_KEY, ADMIN_API_KEY, PRIVATE_BASE_AUTH_URL, ALLOWED_ORG_ID
- * - Configure CLIENT_ID via ADMIN_CONFIG or env variable (CLIENT_ID)
- * - Adjust permission prefix filter via PERMISSION_PREFIX env variable
- *
- * @see https://svelte.dev/docs/kit/remote-functions
- *
- * Usage in your app:
- * ```svelte
- * <script>
- *   import { UserManagement } from '@makolabs/ripple';
- *   import * as adapter from '../UserManagement.remote';
- * </script>
- *
- * <UserManagement adapter={adapter} />
- * ```
- */
 import { query, command } from '$app/server';
+import { getRequestEvent } from '$app/server';
 import { env } from '$env/dynamic/private';
-/**
- * Configuration
- * Override these values or import from your config file
- */
-// Option 1: Import from your config (recommended)
-// import { ADMIN_CONFIG } from '../../constants/permissions';
-// const CLIENT_ID = ADMIN_CONFIG.CLIENT_ID;
-// Option 2: Use environment variable
-const CLIENT_ID = env.CLIENT_ID || 'sharkfin'; // Default fallback
-// Permission prefix filter - adjust based on your permission structure
-// Example: 'sharkfin:' filters to only sharkfin permissions
+const CLIENT_ID = env.CLIENT_ID || 'sharkfin';
 const PERMISSION_PREFIX = env.PERMISSION_PREFIX || 'sharkfin:';
-// Organization ID for adding users to organizations
 const ORGANIZATION_ID = env.ALLOWED_ORG_ID;
-/**
- * Helper: Make authenticated request to Clerk API
- */
+function handleClerkError(error, defaultMessage) {
+    if (error && typeof error === 'object' && 'status' in error && 'details' in error) {
+        const enrichedError = new Error('message' in error && typeof error.message === 'string' ? error.message : 'Unknown error');
+        enrichedError.status = error.status;
+        enrichedError.details = error.details;
+        enrichedError.clerkError = true;
+        throw enrichedError;
+    }
+    throw new Error(`${defaultMessage}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+}
 async function makeClerkRequest(endpoint, options = {}) {
     const CLERK_SECRET_KEY = env.CLERK_SECRET_KEY;
     if (!CLERK_SECRET_KEY) {
@@ -56,8 +29,7 @@ async function makeClerkRequest(endpoint, options = {}) {
     });
     if (!response.ok) {
         const errorText = await response.text();
-        console.error(`❌ [Clerk API] ${response.status} ${response.statusText} - ${errorText}`);
-        // Try to parse error details
+        console.error(`[Clerk API] ${response.status} ${response.statusText} - ${errorText}`);
         let errorDetails;
         try {
             errorDetails = JSON.parse(errorText);
@@ -65,7 +37,6 @@ async function makeClerkRequest(endpoint, options = {}) {
         catch {
             errorDetails = { message: errorText || `${response.status} ${response.statusText}` };
         }
-        // Throw error with status and details for better frontend handling
         const error = new Error(errorDetails.message || `Clerk API request failed: ${response.status} ${response.statusText}`);
         error.status = response.status;
         error.details = errorDetails;
@@ -73,9 +44,6 @@ async function makeClerkRequest(endpoint, options = {}) {
     }
     return response.json();
 }
-/**
- * Helper: Make authenticated request to Admin API
- */
 async function makeAdminRequest(endpoint, options = {}) {
     const ADMIN_API_KEY = env.ADMIN_API_KEY;
     const PRIVATE_BASE_AUTH_URL = env.PRIVATE_BASE_AUTH_URL;
@@ -98,60 +66,39 @@ async function makeAdminRequest(endpoint, options = {}) {
     });
     if (!response.ok) {
         const errorText = await response.text();
-        console.error(`❌ [Admin API] ${response.status} ${response.statusText} - ${errorText}`);
+        console.error(`[Admin API] ${response.status} ${response.statusText} - ${errorText}`);
         throw new Error(`Admin API request failed: ${response.status} ${response.statusText} - ${errorText}`);
     }
     return response.json();
 }
-/**
- * Helper: Create admin key with permissions for a user
- *
- * @param userId - The user ID (used as 'sub' in admin API)
- * @param permissions - Array of permission strings
- * @param clientId - Client ID (defaults to CLIENT_ID config)
- */
 async function createUserPermissions(userId, permissions, clientId = CLIENT_ID) {
-    console.log(`🔑 [createUserPermissions] Creating admin key for user ${userId}`);
-    // Filter permissions by prefix if configured
     const filteredPermissions = PERMISSION_PREFIX
         ? permissions.filter((scope) => scope.startsWith(PERMISSION_PREFIX))
         : permissions;
     if (filteredPermissions.length === 0) {
-        console.log(`⚠️ [createUserPermissions] No ${PERMISSION_PREFIX || ''} permissions provided, skipping`);
         return null;
     }
-    const createData = await makeAdminRequest('/admin/keys', {
+    return await makeAdminRequest('/admin/keys', {
         method: 'POST',
         body: JSON.stringify({
             client_id: clientId,
-            sub: userId, // userId is used as 'sub' parameter
+            sub: userId,
             scopes: filteredPermissions
         })
     });
-    console.log(`✅ [createUserPermissions] Admin key created successfully for user ${userId}`);
-    return createData;
 }
-/**
- * Get users with pagination and sorting
- *
- * Transforms adapter options to Clerk API format
- */
 export const getUsers = query('unchecked', async (options) => {
-    console.log('🔍 [getUsers] Fetching users with options:', options);
     try {
-        // Transform adapter options to Clerk API format
         const limit = options.pageSize;
         const offset = (options.page - 1) * options.pageSize;
-        // Build orderBy string
         let orderBy = '';
         if (options.sortBy) {
             const prefix = options.sortOrder === 'desc' ? '-' : '';
             orderBy = `${prefix}${options.sortBy}`;
         }
         else {
-            orderBy = '-created_at'; // Default
+            orderBy = '-created_at';
         }
-        // Build Clerk API parameters
         const params = new URLSearchParams({
             limit: limit.toString(),
             offset: offset.toString(),
@@ -159,91 +106,66 @@ export const getUsers = query('unchecked', async (options) => {
         });
         if (options.query)
             params.append('query', options.query);
-        // Fetch users and count in parallel
         const [usersData, countData] = await Promise.all([
             makeClerkRequest(`/users?${params}`),
             makeClerkRequest(`/users/count?${params}`)
         ]);
-        console.log(`✅ [getUsers] Fetched ${usersData.length} users, total: ${countData.total_count}`);
         return {
             users: usersData,
             totalUsers: countData.total_count || 0
         };
     }
     catch (error) {
-        console.error('❌ [getUsers] Error:', error);
+        console.error('[getUsers] Error:', error);
         throw new Error(`Failed to fetch users: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 });
-/**
- * Create a new user
- *
- * Creates user in Clerk, optionally adds to organization, and creates admin key with permissions
- */
 export const createUser = command('unchecked', async (userData) => {
-    // Transform User to Clerk API format
     const emailAddress = userData.email_addresses?.[0]?.email_address || '';
     if (!emailAddress) {
         throw new Error('Email address is required');
     }
-    console.log('📝 [createUser] Creating new user:', emailAddress);
     try {
-        // Extract permissions from userData
         const { permissions, ...userDataOnly } = userData;
-        // Transform userData to match Clerk Backend API format (snake_case)
         const clerkUserData = {
             first_name: userDataOnly.first_name || '',
             last_name: userDataOnly.last_name || '',
-            email_address: [emailAddress], // Clerk expects an array
+            email_address: [emailAddress],
             ...(userDataOnly.username && { username: userDataOnly.username }),
             ...(userDataOnly.private_metadata && { private_metadata: userDataOnly.private_metadata })
         };
-        // Step 1: Create user in Clerk
-        console.log('📝 [createUser] Creating user in Clerk...');
         let result = await makeClerkRequest('/users', {
             method: 'POST',
             body: JSON.stringify(clerkUserData)
         });
-        // Step 1.5: Add user to organization if configured
         if (ORGANIZATION_ID) {
             try {
-                console.log(`🏢 [createUser] Adding user ${result.id} to organization ${ORGANIZATION_ID}...`);
                 await makeClerkRequest(`/organizations/${ORGANIZATION_ID}/memberships`, {
                     method: 'POST',
                     body: JSON.stringify({
                         user_id: result.id,
-                        role: 'org:member' // Standard Clerk organization role
+                        role: 'org:member'
                     })
                 });
-                console.log(`✅ [createUser] User added to organization successfully`);
             }
             catch (orgError) {
-                console.error(`❌ [createUser] Failed to add user to organization:`, orgError);
-                // Clean up: delete the user since they can't be added to the org
+                console.error('[createUser] Failed to add user to organization:', orgError);
                 try {
                     await makeClerkRequest(`/users/${result.id}`, {
                         method: 'DELETE'
                     });
-                    console.log(`🗑️ [createUser] User ${result.id} deleted due to org membership failure`);
                 }
                 catch (deleteError) {
-                    console.error(`❌ [createUser] Failed to delete user after org membership failure:`, deleteError);
+                    console.error('[createUser] Failed to delete user after org membership failure:', deleteError);
                 }
                 throw new Error(`Failed to add user to organization. User creation rolled back. Error: ${orgError instanceof Error ? orgError.message : String(orgError)}`);
             }
         }
-        else {
-            console.warn('⚠️ [createUser] ALLOWED_ORG_ID not configured, skipping organization membership');
-        }
-        // Step 2: Create admin key with permissions if permissions are provided
         if (permissions && permissions.length > 0) {
             try {
-                console.log(`🔑 [createUser] Creating permissions for new user: ${result.id}`);
                 const adminKeyResult = await createUserPermissions(result.id, permissions);
-                // Extract the API key from the admin service response
                 const apiKey = adminKeyResult?.data?.key;
                 if (adminKeyResult && apiKey) {
-                    // Update user's private metadata with the API key
                     const updatedUser = await makeClerkRequest(`/users/${result.id}`, {
                         method: 'PATCH',
                         body: JSON.stringify({
@@ -253,60 +175,34 @@ export const createUser = command('unchecked', async (userData) => {
                             }
                         })
                     });
-                    // Update the result with the updated user data
                     result = updatedUser;
-                    console.log(`✅ [createUser] API key stored in user's private metadata`);
                 }
-                else {
-                    console.warn(`⚠️ [createUser] No API key found in admin key result`);
-                }
-                // Add permission info to result
                 result.adminKey = adminKeyResult;
                 result.permissionsAssigned = permissions;
-                console.log(`✅ [createUser] User ${result.id} created with permissions successfully`);
             }
             catch (permissionError) {
-                console.error(`❌ [createUser] Failed to assign permissions:`, permissionError);
-                // Don't fail the entire operation, but warn
+                console.error('[createUser] Failed to assign permissions:', permissionError);
                 result.warning = 'User created but permissions assignment failed';
                 result.permissionError =
                     permissionError instanceof Error ? permissionError.message : String(permissionError);
             }
         }
-        else {
-            console.log(`⚠️ [createUser] User ${result.id} created without permissions`);
-        }
         return result;
     }
     catch (error) {
-        console.error('❌ [createUser] Error:', error);
-        // Handle Clerk API errors with detailed information
-        if (error && typeof error === 'object' && 'status' in error && 'details' in error) {
-            const enrichedError = new Error('message' in error && typeof error.message === 'string' ? error.message : 'Unknown error');
-            enrichedError.status = error.status;
-            enrichedError.details = error.details;
-            enrichedError.clerkError = true;
-            throw enrichedError;
-        }
-        throw new Error(`Failed to create user: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        console.error('[createUser] Error:', error);
+        handleClerkError(error, 'Failed to create user');
     }
 });
-/**
- * Update an existing user
- */
 export const updateUser = command('unchecked', async (options) => {
     const { userId, userData } = options;
-    console.log(`📝 [updateUser] Updating user ${userId}`);
     try {
-        // Transform User to Clerk API format
-        // Only include fields that Clerk accepts
         const updateData = {};
         if (userData.first_name !== undefined)
             updateData.first_name = userData.first_name;
         if (userData.last_name !== undefined)
             updateData.last_name = userData.last_name;
         if (userData.username !== undefined && userData.username !== '') {
-            // Only include username if it's not empty (prevents "username already exists" error)
             updateData.username = userData.username;
         }
         if (userData.private_metadata !== undefined) {
@@ -316,79 +212,49 @@ export const updateUser = command('unchecked', async (options) => {
             method: 'PATCH',
             body: JSON.stringify(updateData)
         });
-        // If permissions changed, update them separately
         if (userData.permissions !== undefined) {
             try {
                 await updateUserPermissions({ userId, permissions: userData.permissions });
             }
             catch (permError) {
-                console.error(`❌ [updateUser] Failed to update permissions:`, permError);
-                // Don't fail the entire operation
+                console.error('[updateUser] Failed to update permissions:', permError);
             }
         }
-        console.log(`✅ [updateUser] User ${userId} updated successfully`);
         return result;
     }
     catch (error) {
-        console.error('❌ [updateUser] Error:', error);
-        // Handle Clerk API errors with detailed information
-        if (error && typeof error === 'object' && 'status' in error && 'details' in error) {
-            const enrichedError = new Error('message' in error && typeof error.message === 'string' ? error.message : 'Unknown error');
-            enrichedError.status = error.status;
-            enrichedError.details = error.details;
-            enrichedError.clerkError = true;
-            throw enrichedError;
-        }
-        throw new Error(`Failed to update user: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        console.error('[updateUser] Error:', error);
+        handleClerkError(error, 'Failed to update user');
     }
 });
-/**
- * Delete a single user
- */
 export const deleteUser = command('unchecked', async (userId) => {
-    console.log(`🗑️ [deleteUser] Deleting user ${userId}`);
     try {
         await makeClerkRequest(`/users/${userId}`, {
             method: 'DELETE'
         });
-        console.log(`✅ [deleteUser] User ${userId} deleted successfully`);
     }
     catch (error) {
-        console.error('❌ [deleteUser] Error:', error);
+        console.error('[deleteUser] Error:', error);
         throw new Error(`Failed to delete user: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 });
-/**
- * Delete multiple users
- */
 export const deleteUsers = command('unchecked', async (userIds) => {
-    console.log(`🗑️ [deleteUsers] Deleting ${userIds.length} users`);
     try {
         await Promise.all(userIds.map((userId) => makeClerkRequest(`/users/${userId}`, {
             method: 'DELETE'
         })));
-        console.log(`✅ [deleteUsers] ${userIds.length} users deleted successfully`);
     }
     catch (error) {
-        console.error('❌ [deleteUsers] Error:', error);
+        console.error('[deleteUsers] Error:', error);
         throw new Error(`Failed to delete users: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 });
-/**
- * Helper: Fetch permissions for a single user
- */
 async function fetchUserPermissions(userId) {
-    console.log(`🔍 [fetchUserPermissions] Fetching permissions for user: ${userId}`);
-    // Try direct lookup first using client_id and sub (userId)
     try {
         const userData = await makeAdminRequest(`/admin/keys?client_id=${CLIENT_ID}&sub=${userId}`);
-        console.log(`✅ [fetchUserPermissions] Direct lookup successful for user ${userId}`);
-        // Filter the response to only include active keys
         if (userData?.data?.data && Array.isArray(userData.data.data)) {
             userData.data.data = userData.data.data.filter((key) => key.status === 'active');
-            console.log(`🔍 [fetchUserPermissions] Filtered to ${userData.data.data.length} active key(s)`);
         }
-        // Extract scopes from the response
         if (userData?.data?.data && Array.isArray(userData.data.data)) {
             return userData.data.data.flatMap((key) => key.scopes || []);
         }
@@ -398,48 +264,28 @@ async function fetchUserPermissions(userId) {
         return [];
     }
     catch {
-        console.log(`❌ [fetchUserPermissions] Direct lookup failed, trying search by sub field`);
-        // If direct lookup fails with 404, search all keys by sub field
         try {
             const allKeysData = await makeAdminRequest('/admin/keys');
-            console.log(`🔍 [fetchUserPermissions] Searching through ${allKeysData.data?.data?.length || 0} keys`);
-            // Find the ACTIVE key for this user (ignore revoked keys)
-            // Match by sub (userId) and client_id
             const userKey = allKeysData.data.data.find((key) => key.sub === userId && key.client_id === CLIENT_ID && key.status === 'active');
             if (userKey) {
-                console.log(`✅ [fetchUserPermissions] Found active user key by sub field`);
                 return Array.isArray(userKey.scopes) ? userKey.scopes : [userKey.scopes];
             }
-            else {
-                console.log(`❌ [fetchUserPermissions] No user found, returning empty permissions`);
-                return [];
-            }
+            return [];
         }
         catch (searchError) {
-            console.error('❌ [fetchUserPermissions] Error searching for user by sub:', searchError);
+            console.error('[fetchUserPermissions] Error searching for user by sub:', searchError);
             throw new Error('Failed to fetch user permissions');
         }
     }
 }
-/**
- * Get permissions for specific users (batched)
- *
- * Uses 'sub' (userId) parameter in admin API calls.
- * Batches multiple permission requests to avoid n+1 problem.
- */
 export const getUserPermissions = query.batch('unchecked', async (userIds) => {
-    console.log(`🔍 [getUserPermissions] Batch fetching permissions for ${userIds.length} users`);
     try {
-        // Fetch all permissions in parallel
         const permissionPromises = userIds.map((userId) => fetchUserPermissions(userId));
         const permissionsResults = await Promise.all(permissionPromises);
-        // Create a lookup map for O(1) access
         const lookup = new Map();
         userIds.forEach((userId, index) => {
             lookup.set(userId, permissionsResults[index]);
         });
-        console.log(`✅ [getUserPermissions] Batch fetch completed for ${userIds.length} users`);
-        // Return a function that SvelteKit will call for each individual request
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         return (userId, _index) => {
             const permissions = lookup.get(userId) || [];
@@ -447,120 +293,122 @@ export const getUserPermissions = query.batch('unchecked', async (userIds) => {
         };
     }
     catch (error) {
-        console.error('❌ [getUserPermissions] Batch error:', error);
-        // Return a function that throws for all requests
+        console.error('[getUserPermissions] Batch error:', error);
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         return (_userId, _index) => {
             throw new Error(`Failed to fetch user permissions: ${error instanceof Error ? error.message : 'Unknown error'}`);
         };
     }
 });
-/**
- * Update permissions for a specific user
- *
- * Uses 'sub' (userId) parameter in admin API calls
- */
+async function refreshTokenIfSelfUpdate(userId) {
+    try {
+        const event = getRequestEvent();
+        if (!event?.locals)
+            return;
+        // Try to get current user - this is app-specific, so we check if the method exists
+        const getAuth = event.locals.auth;
+        if (!getAuth)
+            return;
+        const currentUser = getAuth();
+        const isSelfUpdate = currentUser?.userId === userId;
+        if (isSelfUpdate) {
+            try {
+                // Try to dynamically import token manager - this is app-specific
+                // Use Function constructor to avoid TypeScript checking the import path
+                const importPath = '$lib/server/auth-hooks/token-manager.server';
+                const tokenManager = await new Function('path', 'return import(path)')(importPath).catch(() => null);
+                if (tokenManager?.clearTokenCookies &&
+                    tokenManager?.getAccessToken &&
+                    tokenManager?.setClientAccessibleToken) {
+                    tokenManager.clearTokenCookies(event.cookies);
+                    const newToken = await tokenManager.getAccessToken(event.cookies, event, true);
+                    tokenManager.setClientAccessibleToken(event.cookies, newToken);
+                }
+            }
+            catch {
+                // Token refresh not available in this app, skip silently
+            }
+        }
+    }
+    catch {
+        // Token refresh not available in this app, skip silently
+    }
+}
 export const updateUserPermissions = command('unchecked', async (options) => {
     const { userId, permissions } = options;
-    console.log(`🔑 [updateUserPermissions] Updating permissions for user ${userId}`);
     try {
-        let adminKeyId = userId; // Use userId as default key ID
-        // Try direct update first
+        let adminKeyId = userId;
         try {
             await makeAdminRequest(`/admin/keys/${adminKeyId}`, {
                 method: 'PUT',
                 body: JSON.stringify({ scopes: permissions })
             });
-            console.log(`✅ [updateUserPermissions] Permissions updated successfully`);
+            await refreshTokenIfSelfUpdate(userId);
             return;
         }
         catch {
-            // If direct update fails, try to find the correct adminKeyId
-            console.log(`⚠️ [updateUserPermissions] Direct update failed, searching for key ID...`);
             try {
                 const allKeysData = await makeAdminRequest('/admin/keys');
-                // Find the ACTIVE key for this user (ignore revoked keys)
-                // Match by sub (userId) and client_id
                 const userKey = allKeysData.data.data.find((key) => key.sub === userId && key.client_id === CLIENT_ID && key.status === 'active');
                 if (userKey) {
-                    // Use the found key ID for update
                     adminKeyId = userKey.id;
                     await makeAdminRequest(`/admin/keys/${adminKeyId}`, {
                         method: 'PUT',
                         body: JSON.stringify({ scopes: permissions })
                     });
-                    console.log(`✅ [updateUserPermissions] Permissions updated successfully (after search)`);
+                    await refreshTokenIfSelfUpdate(userId);
                     return;
                 }
                 else {
-                    // User doesn't exist, create new admin key
-                    console.log(`📝 [updateUserPermissions] Creating new admin key...`);
                     await createUserPermissions(userId, permissions);
-                    console.log(`✅ [updateUserPermissions] New admin key created successfully`);
+                    await refreshTokenIfSelfUpdate(userId);
                     return;
                 }
             }
             catch (searchError) {
-                console.error('❌ [updateUserPermissions] Error during permission update:', searchError);
+                console.error('[updateUserPermissions] Error during permission update:', searchError);
                 throw new Error('Failed to update permissions');
             }
         }
     }
     catch (error) {
-        console.error('❌ [updateUserPermissions] Error:', error);
+        console.error('[updateUserPermissions] Error:', error);
         throw new Error(`Failed to update user permissions: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 });
-/**
- * Generate new API key for a user with optional old key revocation
- */
 export const generateApiKey = command('unchecked', async (options) => {
-    console.log(`🔑 [generateApiKey] Generating new API key for user ${options.userId}`);
     try {
-        // Filter permissions by prefix if configured
         const filteredPermissions = PERMISSION_PREFIX
             ? options.permissions.filter((scope) => scope.startsWith(PERMISSION_PREFIX))
             : options.permissions;
         if (filteredPermissions.length === 0) {
             throw new Error(`At least one ${PERMISSION_PREFIX || ''} permission is required to generate an API key`);
         }
-        // If revokeOld is true, find and revoke the old key first
         let oldKeyId = null;
         if (options.revokeOld) {
             try {
-                console.log(`🔍 [generateApiKey] Looking for existing active key to revoke`);
                 const allKeysData = await makeAdminRequest('/admin/keys');
-                if (!allKeysData?.data?.data || !Array.isArray(allKeysData.data.data)) {
-                    console.warn('⚠️ [generateApiKey] Unexpected response structure from /admin/keys');
-                }
-                else {
-                    // Find the ACTIVE key for this user (ignore already revoked keys)
+                if (allKeysData?.data?.data && Array.isArray(allKeysData.data.data)) {
                     const userKey = allKeysData.data.data.find((key) => key.sub === options.userId && key.client_id === CLIENT_ID && key.status === 'active');
                     if (userKey) {
                         oldKeyId = userKey.id;
-                        console.log(`📌 [generateApiKey] Found existing active key: ${oldKeyId}`);
                     }
                 }
             }
             catch (e) {
-                console.warn('⚠️ [generateApiKey] Could not fetch existing key for revocation:', e);
-                // Continue anyway - not critical
+                console.warn('[generateApiKey] Could not fetch existing key for revocation:', e);
             }
         }
-        // Create new admin key
         const createData = await createUserPermissions(options.userId, filteredPermissions);
         if (!createData) {
             throw new Error('Failed to create admin key');
         }
         const newApiKey = createData?.data?.key;
         if (!newApiKey) {
-            console.error('❌ [generateApiKey] No API key in response:', createData);
+            console.error('[generateApiKey] No API key in response:', createData);
             throw new Error('Failed to generate API key - no key in response');
         }
-        console.log(`✅ [generateApiKey] New API key generated successfully`);
-        // Update user's Clerk profile with the new API key
         try {
-            // First, get the current user data to preserve existing private_metadata
             const currentUser = await makeClerkRequest(`/users/${options.userId}`);
             await makeClerkRequest(`/users/${options.userId}`, {
                 method: 'PATCH',
@@ -571,24 +419,20 @@ export const generateApiKey = command('unchecked', async (options) => {
                     }
                 })
             });
-            console.log(`✅ [generateApiKey] API key stored in user's Clerk profile`);
         }
         catch (clerkError) {
-            console.error('❌ [generateApiKey] Failed to update Clerk profile:', clerkError);
-            console.warn('⚠️ [generateApiKey] Key generated but could not update Clerk profile');
+            console.error('[generateApiKey] Failed to update Clerk profile:', clerkError);
+            console.warn('[generateApiKey] Key generated but could not update Clerk profile');
         }
-        // Revoke old key if it exists
         if (oldKeyId) {
             try {
-                console.log(`🗑️ [generateApiKey] Revoking old key: ${oldKeyId}`);
                 await makeAdminRequest(`/admin/keys/${oldKeyId}`, {
                     method: 'DELETE'
                 });
-                console.log(`✅ [generateApiKey] Old key revoked successfully`);
             }
             catch (revokeError) {
-                console.error('❌ [generateApiKey] Failed to revoke old key:', revokeError);
-                console.warn('⚠️ [generateApiKey] New key generated but could not revoke old key');
+                console.error('[generateApiKey] Failed to revoke old key:', revokeError);
+                console.warn('[generateApiKey] New key generated but could not revoke old key');
             }
         }
         return {
@@ -600,7 +444,7 @@ export const generateApiKey = command('unchecked', async (options) => {
         };
     }
     catch (error) {
-        console.error('❌ [generateApiKey] Error:', error);
+        console.error('[generateApiKey] Error:', error);
         throw new Error(`Failed to generate API key: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 });

package/dist/user-management/adapters/index.d.ts

@@ -7,4 +7,5 @@
  * @see https://svelte.dev/docs/kit/remote-functions
  */
 export type { GetUsersOptions, GetUsersResult } from './types.js';
-export * from './mockUserManagement.js';
+export * from './UserManagement.remote.js';
+export * as MockUserManagement from './mockUserManagement.js';

package/dist/user-management/adapters/index.js

@@ -6,7 +6,7 @@
  *
  * @see https://svelte.dev/docs/kit/remote-functions
  */
-// Export mock adapter functions for testing/storybook
-export * from './mockUserManagement.js';
-// Note: UserManagement.remote.ts is a template file showing how to implement
-// remote functions in your SvelteKit app. It is not exported from this library.
+// Export default remote functions implementation
+export * from './UserManagement.remote.js';
+// Export mock adapter functions for testing/storybook (with different names to avoid conflicts)
+export * as MockUserManagement from './mockUserManagement.js';

package/dist/user-management/user-management.d.ts

@@ -110,6 +110,7 @@ export interface UserManagementProps {
     /**
      * Adapter module containing remote functions or async functions
      * Should be imported from a .remote.ts file
+     * If not provided, uses the default adapter from @makolabs/ripple
      *
      * Example:
      * ```ts
@@ -117,7 +118,7 @@ export interface UserManagementProps {
      * <UserManagement adapter={adapter} roles={roles} />
      * ```
      */
-    adapter: UserManagementAdapter;
+    adapter?: UserManagementAdapter;
     /**
      * Available roles for user assignment
      */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@makolabs/ripple",
-	"version": "1.2.10",
+	"version": "1.2.12",
 	"description": "Simple Svelte 5 powered component library ✨",
 	"license": "SEE LICENSE IN LICENSE",
 	"repository": {