Update allowed users API and add personal mode

- Fix TypeScript error in allowedUsers.api.ts with proper type casting
- Update API endpoints to use unified /api/settings endpoint
- Update response parsing for new nested settings.allowed_users structure
- Update request format to send data in settings.allowed_users structure
- Add new 'personal' mode for single-user private relays
- Update mode labels for better clarity:
  * free -> 'Free - Public Relay'
  * paid -> 'Paid - Subscription Tiers'
  * exclusive -> 'Free - Invite Only'
  * personal -> 'Free - Only Me' (NEW)
- Add personal mode configuration with unlimited access and NPUB management
- Update API logic to handle personal mode like free mode for tier filtering

Author: Maphikza

src/api/allowedUsers.api.ts

@@ -6,13 +6,14 @@ import {
   AllowedUsersNpubsResponse,
   BulkImportRequest,
   AllowedUsersNpub,
+  AllowedUsersMode,
   DEFAULT_TIERS
 } from '@app/types/allowedUsers.types';
 
 // Settings Management
 export const getAllowedUsersSettings = async (): Promise<AllowedUsersSettings> => {
   const token = readToken();
-  const response = await fetch(`${config.baseURL}/api/settings/allowed_users`, {
+  const response = await fetch(`${config.baseURL}/api/settings`, {
     headers: {
       'Authorization': `Bearer ${token}`,
     },
@@ -22,25 +23,47 @@ export const getAllowedUsersSettings = async (): Promise<AllowedUsersSettings> =
 
   const text = await response.text();
   try {
-    const data: AllowedUsersApiResponse = JSON.parse(text);
+    const data = JSON.parse(text);
+    
+    // Extract allowed_users from the new nested structure
+    const allowedUsersData = data.settings?.allowed_users;
+    if (!allowedUsersData) {
+      throw new Error('No allowed_users data found in response');
+    }
 
     // Transform tiers from backend format to frontend format
-    let transformedTiers = data.allowed_users.tiers.map(tier => ({
-      data_limit: (tier as any).datalimit || tier.data_limit || '',
-      price: tier.price
-    }));
+    let transformedTiers = [];
+    
+    // Check if tiers exist in response, otherwise use defaults
+    if (allowedUsersData.tiers && Array.isArray(allowedUsersData.tiers)) {
+      transformedTiers = allowedUsersData.tiers.map((tier: any) => ({
+        data_limit: tier.datalimit || tier.data_limit || '',
+        price: tier.price || '0'
+      }));
+    } else {
+      // Use default tiers for the mode if none provided
+      const mode = allowedUsersData.mode as AllowedUsersMode;
+      transformedTiers = DEFAULT_TIERS[mode] || DEFAULT_TIERS.free;
+    }
 
     // For free mode, reconstruct full UI options with active tier marked
-    if (data.allowed_users.mode === 'free' && transformedTiers.length === 1) {
+    if (allowedUsersData.mode === 'free' && transformedTiers.length === 1) {
       const activeTierDataLimit = transformedTiers[0].data_limit;
       transformedTiers = DEFAULT_TIERS.free.map(defaultTier => ({
         ...defaultTier,
         active: defaultTier.data_limit === activeTierDataLimit
       }));
     }
 
+    // For personal mode, reconstruct with single unlimited tier
+    if (allowedUsersData.mode === 'personal' && transformedTiers.length === 1) {
+      transformedTiers = DEFAULT_TIERS.personal;
+    }
+    
     const transformedSettings = {
-      ...data.allowed_users,
+      mode: allowedUsersData.mode || 'free',
+      read_access: allowedUsersData.read_access || { enabled: true, scope: 'all_users' },
+      write_access: allowedUsersData.write_access || { enabled: true, scope: 'all_users' },
       tiers: transformedTiers
     };
 
@@ -53,33 +76,35 @@ export const getAllowedUsersSettings = async (): Promise<AllowedUsersSettings> =
 export const updateAllowedUsersSettings = async (settings: AllowedUsersSettings): Promise<{ success: boolean, message: string }> => {
   const token = readToken();
 
-  // Filter tiers based on mode - for free mode, only send active tier
-  const tiersToSend = settings.mode === 'free' 
+  // Filter tiers based on mode - for free and personal modes, only send active tier
+  const tiersToSend = (settings.mode === 'free' || settings.mode === 'personal')
     ? settings.tiers.filter(tier => tier.active)
     : settings.tiers;
 
-  // Transform to nested format as expected by backend
+  // Transform to nested format as expected by new unified backend API
   const nestedSettings = {
-    "allowed_users": {
-      "mode": settings.mode,
-      "read_access": {
-        "enabled": settings.read_access.enabled,
-        "scope": settings.read_access.scope
-      },
-      "write_access": {
-        "enabled": settings.write_access.enabled,
-        "scope": settings.write_access.scope
-      },
-      "tiers": tiersToSend.map(tier => ({
-        "datalimit": tier.data_limit || "1 GB per month",  // Backend expects 'datalimit' not 'data_limit', fallback for empty values
-        "price": tier.price || "0"
-      }))
+    "settings": {
+      "allowed_users": {
+        "mode": settings.mode,
+        "read_access": {
+          "enabled": settings.read_access.enabled,
+          "scope": settings.read_access.scope
+        },
+        "write_access": {
+          "enabled": settings.write_access.enabled,
+          "scope": settings.write_access.scope
+        },
+        "tiers": tiersToSend.map(tier => ({
+          "datalimit": tier.data_limit || "1 GB per month",  // Backend expects 'datalimit' not 'data_limit', fallback for empty values
+          "price": tier.price || "0"
+        }))
+      }
     }
   };
 
   console.log('Sending to backend:', JSON.stringify(nestedSettings, null, 2));
 
-  const response = await fetch(`${config.baseURL}/api/settings/allowed_users`, {
+  const response = await fetch(`${config.baseURL}/api/settings`, {
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',
@@ -97,9 +122,10 @@ export const updateAllowedUsersSettings = async (settings: AllowedUsersSettings)
   }
 
   try {
-    return JSON.parse(text);
+    return JSON.parse(text) || { success: true, message: 'Settings updated successfully' };
   } catch (jsonError) {
-    throw new Error(`Invalid JSON response: ${text}`);
+    // If response is not JSON, assume success if status was OK
+    return { success: true, message: 'Settings updated successfully' };
   }
 };
 

src/components/allowed-users/components/ModeSelector/ModeSelector.tsx

@@ -11,19 +11,24 @@ interface ModeSelectorProps {
 
 const MODE_INFO = {
   free: {
-    label: 'Free Mode',
+    label: 'Free - Public Relay',
     description: 'Open access with optional free tiers',
     color: '#1890ff'
   },
   paid: {
-    label: 'Paid Mode', 
+    label: 'Paid - Subscription Tiers', 
     description: 'Subscription-based access control',
     color: '#52c41a'
   },
   exclusive: {
-    label: 'Exclusive Mode',
+    label: 'Free - Invite Only',
     description: 'Invite-only access with manual NPUB management',
     color: '#722ed1'
+  },
+  personal: {
+    label: 'Free - Only Me',
+    description: 'Personal relay for single user with unlimited access',
+    color: '#fa541c'
   }
 };
 

src/types/allowedUsers.types.ts

@@ -1,4 +1,4 @@
-export type AllowedUsersMode = 'free' | 'paid' | 'exclusive';
+export type AllowedUsersMode = 'free' | 'paid' | 'exclusive' | 'personal';
 
 export type AccessScope = 'all_users' | 'paid_users' | 'allowed_users';
 
@@ -91,6 +91,16 @@ export const MODE_CONFIGURATIONS: Record<AllowedUsersMode, ModeOptions> = {
     ],
     allowsFreeTiers: true,
     requiresNpubManagement: true
+  },
+  personal: {
+    readOptions: [
+      { value: 'allowed_users', label: 'Only Me' }
+    ],
+    writeOptions: [
+      { value: 'allowed_users', label: 'Only Me' }
+    ],
+    allowsFreeTiers: true,
+    requiresNpubManagement: true
   }
 };
 
@@ -110,5 +120,8 @@ export const DEFAULT_TIERS: Record<AllowedUsersMode, AllowedUsersTier[]> = {
     { data_limit: '5 GB per month', price: '0' },
     { data_limit: '50 GB per month', price: '0' },
     { data_limit: 'unlimited', price: '0' }
+  ],
+  personal: [
+    { data_limit: 'unlimited', price: '0', active: true } // Personal use, unlimited and free
   ]
 };