apps-sdk 2.1.1 → 2.1.3

package/src/libraries/Authentication.js

@@ -0,0 +1,799 @@
+/**
+ * ChatConnect Authentication Service Layer
+ * -----------------------------------------
+ * Handles all authentication-related API calls including:
+ * - Login (auth-user)
+ * - Registration (create-user)
+ * - User linking
+ * - Subscription checking
+ *
+ * API Base URLs:
+ * - Auth: https://bc1742.gways.org/auth/
+ * - ChatConnect: https://bc1742.gways.org/chatconnect/
+ * - User: https://bc1742.gways.org/user/
+ */
+
+import Storage from './Storage';
+import Session from './Session';
+import Networking from './Networking';
+import config from '../../config';
+
+const BASE_URL = 'https://bc1742.gways.org';
+const AUTH_BASE_URL = `${BASE_URL}/auth`;
+const CHATCONNECT_BASE_URL = `${BASE_URL}/chatconnect`;
+const USER_BASE_URL = `${BASE_URL}/user`;
+
+class Authentication {
+    constructor() {
+        this.AUTH_API_BASE_URL = AUTH_BASE_URL;
+        this.USER_API_BASE_URL = USER_BASE_URL;
+        this.CHATCONNECT_API_BASE_URL = CHATCONNECT_BASE_URL;
+    }
+
+    /**
+     * Get website ID from config
+     * @returns {string}
+     */
+    getWebsiteId() {
+        return config.CONFIG_EXTRA?.website_id || 'chatconnect-web';
+    }
+
+    /**
+     * Helper to get app user ID from session
+     * @returns {string}
+     */
+    getAppUserId() {
+        try {
+            const userId = Session?.getUserID?.();
+            return userId ?? '';
+        } catch {
+            return '';
+        }
+    }
+
+    /**
+     * Generic API call helper with retry logic
+     * @param {string} url - API endpoint URL
+     * @param {Object} payload - Request payload
+     * @param {Object} opts - Options (retries, timeoutMs, silent)
+     * @returns {Promise<Object>} API result
+     */
+    async callApi(url, payload, opts = {}) {
+        const { retries = 2, timeoutMs = 15000 } = opts;
+
+        let attempt = 0;
+        let lastError = null;
+
+        while (attempt <= retries) {
+            try {
+                const controller = new AbortController();
+                const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+                const response = await Networking.request(url, payload);
+                clearTimeout(timeout);
+
+                // Handle error responses
+                if (response?.success === 0 || response?.success === false) {
+                    return {
+                        success: false,
+                        error: response.msg || response.message || response.error || 'Request failed',
+                        code: response.code,
+                        raw: response,
+                    };
+                }
+
+                // Extract data from response
+                const data = response?.data ?? response;
+                return {
+                    success: true,
+                    data: data,
+                    message: response?.msg || response?.message,
+                    raw: response,
+                };
+            } catch (err) {
+                lastError = err;
+                const isAbort = err?.name === 'AbortError';
+                const transient =
+                    isAbort ||
+                    (err?.message && /(timeout|network|fetch failed|abort)/i.test(err.message));
+
+                if (!transient || attempt === retries) {
+                    config.DEBUG_MODE && console.debug('API call failed:', url, err?.message);
+                    return {
+                        success: false,
+                        error: err?.message || 'Unknown error',
+                        raw: err,
+                    };
+                }
+
+                // Backoff before retry
+                await new Promise((res) => setTimeout(res, 400 * (attempt + 1)));
+            }
+            attempt++;
+        }
+
+        config.DEBUG_MODE && console.debug('API call failed after retries:', url, lastError?.message);
+        return { success: false, error: lastError?.message || 'Unknown error', raw: lastError };
+    }
+
+    /**
+     * Login with credentials (auth-user)
+     * POST https://bc1742.gways.org/auth/auth-user
+     * 
+     * @param {Object} payload - Login payload
+     * @param {string} payload.login - Email or username (or credential)
+     * @param {string} payload.password - Password
+     * @param {string} [payload.websiteid] - Optional website ID
+     * @returns {Promise<Object>} Login result
+     */
+    async login(payload) {
+        // Handle both old and new payload formats
+        const loginValue = 'login' in payload ? payload.login : payload.credential;
+        
+        const requestPayload = {
+            login: loginValue,
+            password: payload.password,
+            websiteid: ('websiteid' in payload ? payload.websiteid : undefined) || this.getWebsiteId(),
+        };
+        
+        const url = `${AUTH_BASE_URL}/auth-user`;
+        const result = await this.callApi(url, requestPayload);
+        
+        // Check if we got a response but with success: 0 inside data
+        if (result.success && result.data && result.data.success === 0) {
+            return {
+                success: false,
+                error: 'user_not_found',
+                data: result.data,
+                raw: result.raw,
+            };
+        }
+        
+        // Store user data if login successful
+        if (result.success && result.data && result.data.success === 1) {
+            try {
+                await Storage.storeData('AUTH_USER_ID', result.data.us_id);
+                await Storage.storeData('AUTH_USER_LOGIN', result.data.us_login);
+                // Store credentials for auto-linking later
+                await Storage.storeData('AUTH_CREDENTIALS', JSON.stringify({
+                    login: loginValue,
+                    password: payload.password,
+                }));
+                // Handle metadata (can be array if empty or object if populated)
+                if (result.data.metadata && !Array.isArray(result.data.metadata)) {
+                    await Storage.storeData('AUTH_USER_METADATA', JSON.stringify(result.data.metadata));
+                } else {
+                    await Storage.removeData('AUTH_USER_METADATA');
+                }
+                if (result.data.subscription_data) {
+                    await Storage.storeData('AUTH_SUBSCRIPTION', JSON.stringify(result.data.subscription_data));
+                }
+            } catch (e) {
+                console.warn('Failed to store auth data:', e);
+            }
+        }
+        
+        return result;
+    }
+
+    /**
+     * Register a new user account (create-user)
+     * POST https://bc1742.gways.org/chatconnect/create-user
+     * 
+     * @param {Object} payload - Registration payload
+     * @param {string} payload.login - Email or username (or email field)
+     * @param {string} payload.password - Password
+     * @param {string} [payload.websiteid] - Optional website ID
+     * @returns {Promise<Object>} Registration result
+     */
+    async register(payload) {
+        // Handle both old and new payload formats
+        const loginValue = 'login' in payload ? payload.login : payload.email;
+        
+        const requestPayload = {
+            login: loginValue,
+            password: payload.password,
+            websiteid: ('websiteid' in payload ? payload.websiteid : undefined) || this.getWebsiteId(),
+        };
+        
+        const url = `${CHATCONNECT_BASE_URL}/create-user`;
+        const result = await this.callApi(url, requestPayload);
+        
+        // Store user data and credentials on successful registration
+        if (result.success && result.data?.user) {
+            const userData = result.data.user;
+            try {
+                await Storage.storeData('AUTH_USER_ID', String(userData.us_id));
+                await Storage.storeData('AUTH_USER_LOGIN', userData.login);
+                await Storage.storeData('AUTH_CREDENTIALS', JSON.stringify({
+                    login: loginValue,
+                    password: payload.password,
+                }));
+            } catch (e) {
+                console.warn('Failed to store user data:', e);
+            }
+        }
+        
+        return result;
+    }
+
+    /**
+     * Complete registration flow: create-user → link-user
+     * 
+     * @param {Object} payload - Registration payload
+     * @param {string} payload.email - Email
+     * @param {string} payload.password - Password
+     * @returns {Promise<Object>} Complete registration result
+     */
+    async registerAndLinkAccount(payload) {
+        // Step 1: Create user account
+        const createResult = await this.register({
+            login: payload.email.trim(),
+            password: payload.password,
+            websiteid: this.getWebsiteId(),
+        });
+
+        if (!createResult.success) {
+            if (createResult.code === 112) {
+                return {
+                    success: false,
+                    error: 'user_already_exists',
+                    code: 112,
+                };
+            }
+            return {
+                success: false,
+                error: createResult.error || 'registration_failed',
+                code: createResult.code,
+            };
+        }
+
+        const userData = createResult.data?.user || (createResult.raw?.data?.user);
+        
+        if (!userData?.us_id) {
+            return {
+                success: false,
+                error: 'registration_failed',
+            };
+        }
+
+        // Store the web user credentials
+        try {
+            await Storage.storeData('WEB_USER_ID', String(userData.us_id));
+            await Storage.storeData('WEB_USER_LOGIN', userData.login);
+            await Storage.storeData('AUTH_USER_ID', String(userData.us_id));
+            await Storage.storeData('AUTH_USER_LOGIN', userData.login);
+        } catch (e) {
+            console.warn('Failed to store web user data:', e);
+        }
+
+        // Step 2: Link web user with mobile app user
+        const appUserId = this.getAppUserId();
+        
+        if (!appUserId) {
+            return {
+                success: true,
+                user: userData,
+                linked: false,
+                error: 'app_user_id_not_available',
+            };
+        }
+
+        const linkResult = await this.linkUser({
+            user_id: String(userData.us_id),
+            app_user_id: appUserId,
+        });
+
+        if (!linkResult.success) {
+            if (linkResult.code === 111) {
+                return {
+                    success: true,
+                    user: userData,
+                    linked: false,
+                    error: 'web_user_not_found',
+                    code: 111,
+                };
+            }
+            return {
+                success: true,
+                user: userData,
+                linked: false,
+                error: linkResult.error || 'link_failed',
+                code: linkResult.code,
+            };
+        }
+
+        const isLinked = true;
+
+        // Store linked status
+        try {
+            await Storage.storeData('ACCOUNT_LINKED', 'true');
+            await Storage.storeData('LINKED_WEB_USER_ID', String(userData.us_id));
+        } catch (e) {
+            console.warn('Failed to store linked status:', e);
+        }
+
+        return {
+            success: true,
+            user: userData,
+            linked: isLinked,
+        };
+    }
+
+    /**
+     * Link a user account
+     * POST https://bc1742.gways.org/user/link
+     * 
+     * @param {Object} payload - Link payload
+     * @param {string} payload.user_id - Web user ID
+     * @param {string} payload.app_user_id - Mobile app user ID
+     * @returns {Promise<Object>} Link result
+     */
+    async linkUser(payload) {
+        const url = `${USER_BASE_URL}/link`;
+        const result = await this.callApi(url, payload);
+        
+        if (!result.success) {
+            return {
+                success: false,
+                error: result.error,
+                code: result.code,
+                raw: result.raw,
+            };
+        }
+        
+        const rawData = result.data;
+        
+        if (Array.isArray(rawData) && rawData.length > 0) {
+            const userData = rawData[0];
+            
+            // Store user data from link response
+            try {
+                if (userData.us_id) {
+                    await Storage.storeData('AUTH_USER_ID', String(userData.us_id));
+                }
+                if (userData.us_login) {
+                    await Storage.storeData('AUTH_USER_LOGIN', userData.us_login);
+                }
+                if (userData.metadata && !Array.isArray(userData.metadata)) {
+                    await Storage.storeData('AUTH_USER_METADATA', JSON.stringify(userData.metadata));
+                }
+                if (userData.subscription_data) {
+                    await Storage.storeData('AUTH_SUBSCRIPTION', JSON.stringify(userData.subscription_data));
+                }
+            } catch (e) {
+                console.warn('Failed to store user data from link response:', e);
+            }
+            
+            return {
+                success: true,
+                data: {
+                    success: userData.success,
+                    linked: userData.success === 1,
+                    items: rawData,
+                },
+                raw: result.raw,
+            };
+        }
+        
+        // Handle legacy response format
+        if (rawData && typeof rawData === 'object' && 'success' in rawData) {
+            return {
+                success: true,
+                data: {
+                    success: rawData.success ? 1 : 0,
+                    linked: !!rawData.success,
+                },
+                raw: result.raw,
+            };
+        }
+        
+        return {
+            success: true,
+            data: {
+                success: 1,
+                linked: true,
+            },
+            raw: result.raw,
+        };
+    }
+
+    /**
+     * Fetch authenticated user profile using stored credentials
+     * @returns {Promise<Object>} User profile result
+     */
+    async fetchUserProfile() {
+        try {
+            const credentialsJson = await Storage.getData('AUTH_CREDENTIALS');
+            if (!credentialsJson) {
+                return {
+                    success: false,
+                    error: 'no_stored_credentials',
+                };
+            }
+
+            const credentials = JSON.parse(credentialsJson);
+            if (!credentials.login || !credentials.password) {
+                return {
+                    success: false,
+                    error: 'invalid_stored_credentials',
+                };
+            }
+
+            return await this.login({
+                login: credentials.login,
+                password: credentials.password,
+                websiteid: this.getWebsiteId(),
+            });
+        } catch (e) {
+            config.DEBUG_MODE && console.debug('Failed to fetch user profile:', e?.message);
+            return {
+                success: false,
+                error: 'fetch_profile_failed',
+            };
+        }
+    }
+
+    /**
+     * Check if user account is linked
+     * @returns {Promise<boolean>}
+     */
+    async isAccountLinked() {
+        try {
+            const linked = await Storage.getData('ACCOUNT_LINKED');
+            if (linked === 'true') {
+                return true;
+            }
+            
+            const userId = await Storage.getData('AUTH_USER_ID');
+            if (userId) {
+                await Storage.storeData('ACCOUNT_LINKED', 'true');
+                return true;
+            }
+            
+            return false;
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * Get stored auth user login (email)
+     * @returns {Promise<string|null>}
+     */
+    async getStoredUserLogin() {
+        try {
+            return await Storage.getData('AUTH_USER_LOGIN');
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * Check if user is linked
+     * POST https://bc1742.gways.org/user/check-link
+     * 
+     * @param {Object} payload - Check link payload
+     * @param {string} payload.user_id - User ID
+     * @param {string} payload.app_user_id - App user ID
+     * @returns {Promise<Object>} Check link result
+     */
+    async checkLink(payload) {
+        const url = `${USER_BASE_URL}/check-link`;
+        return this.callApi(url, payload);
+    }
+
+    /**
+     * Check user subscription status
+     * POST https://bc1742.gways.org/user/check-subs
+     * 
+     * @param {Object} payload - Check subscription payload
+     * @param {string} payload.user_id - User ID
+     * @param {string} payload.app_user_id - App user ID
+     * @returns {Promise<Object>} Subscription status result
+     */
+    async checkSubscription(payload) {
+        const url = `${USER_BASE_URL}/check-subs`;
+        return this.callApi(url, payload);
+    }
+
+    /**
+     * Check if a credential exists (stub - for backward compatibility)
+     * @param {Object} payload - Check credential payload
+     * @returns {Promise<Object>} Credential check result
+     */
+    async checkCredential(payload) {
+        return {
+            success: true,
+            data: {
+                exists: true,
+                credentialType: payload.credentialType,
+                requiresPhone: false,
+            },
+        };
+    }
+
+    /**
+     * Validate phone number (basic client-side validation)
+     * @param {Object} payload - Validate phone payload
+     * @returns {Promise<Object>} Phone validation result
+     */
+    async validatePhone(payload) {
+        const phone = payload.phoneNumber.replace(/\D/g, '');
+        const isValid = phone.length >= 6 && phone.length <= 15;
+        
+        return {
+            success: true,
+            data: {
+                valid: isValid,
+                formattedPhone: isValid ? `${payload.countryCode}${phone}` : undefined,
+            },
+        };
+    }
+
+    /**
+     * Request password reset (stub - to be implemented on backend)
+     * @param {Object} payload - Password reset request payload
+     * @returns {Promise<Object>} Password reset request result
+     */
+    async requestPasswordReset(payload) {
+        return {
+            success: true,
+            data: {
+                sent: true,
+                destination: payload.credential,
+                expiresIn: 300,
+            },
+        };
+    }
+
+    /**
+     * Verify reset code (stub - to be implemented on backend)
+     * @param {Object} payload - Verify code payload
+     * @returns {Promise<Object>} Verification result
+     */
+    async verifyResetCode(payload) {
+        const isValid = payload.code.length === 6 && /^\d+$/.test(payload.code);
+        
+        return {
+            success: isValid,
+            data: isValid ? {
+                valid: true,
+                resetToken: payload.code,
+            } : undefined,
+            error: isValid ? undefined : 'Invalid code',
+        };
+    }
+
+    /**
+     * Reset password (stub - to be implemented on backend)
+     * @param {Object} payload - Reset password payload
+     * @returns {Promise<Object>} Password reset result
+     */
+    async resetPassword(payload) {
+        return {
+            success: true,
+            data: {
+                success: true,
+                message: 'Password reset successfully',
+            },
+        };
+    }
+
+    /**
+     * Resend verification code (stub - to be implemented on backend)
+     * @param {Object} payload - Resend code payload
+     * @returns {Promise<Object>} Resend code result
+     */
+    async resendCode(payload) {
+        return {
+            success: true,
+            data: {
+                sent: true,
+                canResendAt: new Date(Date.now() + 60000).toISOString(),
+            },
+        };
+    }
+
+    /**
+     * Validate QR code data
+     * @param {Object} payload - QR code validation payload
+     * @param {string} payload.qrData - QR code data
+     * @returns {Promise<Object>} QR code validation result
+     */
+    async validateQrCode(payload) {
+        const qrData = payload.qrData.trim();
+        
+        let userId;
+        
+        if (/^\d+$/.test(qrData)) {
+            userId = qrData;
+        } else {
+            try {
+                const parsed = JSON.parse(qrData);
+                userId = parsed.user_id || parsed.userId || parsed.us_id;
+            } catch {
+                const match = qrData.match(/(?:user_id|us_id)[=:](\d+)/i);
+                if (match) {
+                    userId = match[1];
+                }
+            }
+        }
+        
+        if (!userId || !/^\d+$/.test(userId)) {
+            return {
+                success: false,
+                data: { valid: false },
+                error: 'Invalid QR code format',
+            };
+        }
+        
+        return {
+            success: true,
+            data: {
+                valid: true,
+                user_id: userId,
+            },
+        };
+    }
+
+    /**
+     * Link account using QR code
+     * POST https://bc1742.gways.org/user/link
+     * 
+     * @param {Object} payload - QR link payload
+     * @param {string} payload.user_id - User ID from QR code
+     * @returns {Promise<Object>} QR link result
+     */
+    async linkWithQrCode(payload) {
+        const appUserId = this.getAppUserId();
+        
+        if (!appUserId) {
+            return {
+                success: false,
+                error: 'App user ID not available',
+                data: { linked: false },
+            };
+        }
+        
+        const token = payload.user_id?.trim();
+        
+        if (!token) {
+            return {
+                success: false,
+                error: 'Token not provided',
+                data: { linked: false },
+            };
+        }
+        
+        config.DEBUG_MODE && console.debug('[linkWithQrCode] Linking with token:', token);
+        
+        const result = await this.linkUser({
+            user_id: token,
+            app_user_id: appUserId,
+        });
+        
+        if (result.success) {
+            try {
+                await Storage.storeData('ACCOUNT_LINKED', 'true');
+                await Storage.storeData('LINKED_WEB_USER_ID', token);
+                
+                const userData = result.data?.items?.[0];
+                if (userData?.us_id) {
+                    await Storage.storeData('AUTH_USER_ID', String(userData.us_id));
+                } else {
+                    await Storage.storeData('AUTH_USER_ID', token);
+                }
+            } catch (e) {
+                console.warn('Failed to store linked status:', e);
+            }
+            
+            const userData = result.data?.items?.[0];
+            const subscriptionActive = userData?.subscription_data?.subscription_active === true;
+            
+            return {
+                success: true,
+                data: {
+                    linked: true,
+                    message: 'Account linked successfully',
+                    subscriptionActive,
+                },
+            };
+        }
+        
+        // Handle "already linked" as success
+        if (result.code === 115) {
+            try {
+                await Storage.storeData('ACCOUNT_LINKED', 'true');
+                await Storage.storeData('AUTH_USER_ID', token);
+                await Storage.storeData('LINKED_WEB_USER_ID', token);
+            } catch (e) {
+                console.warn('Failed to store linked status:', e);
+            }
+            
+            return {
+                success: true,
+                data: {
+                    linked: true,
+                    message: 'Account already linked',
+                },
+            };
+        }
+        
+        return {
+            success: false,
+            error: result.error || 'Failed to link account',
+            data: { linked: false },
+        };
+    }
+
+    /**
+     * Logout current user
+     * @returns {Promise<Object>} Logout result
+     */
+    async logout() {
+        try {
+            await Storage.removeData('AUTH_USER_ID');
+            await Storage.removeData('AUTH_USER_LOGIN');
+            await Storage.removeData('AUTH_USER_METADATA');
+            await Storage.removeData('AUTH_SUBSCRIPTION');
+        } catch (e) {
+            console.warn('Failed to clear auth data:', e);
+        }
+        
+        return { success: true, data: { success: true } };
+    }
+
+    /**
+     * Check if user is currently authenticated
+     * @returns {Promise<boolean>}
+     */
+    async isAuthenticated() {
+        try {
+            const userId = await Storage.getData('AUTH_USER_ID');
+            return !!userId;
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * Get stored user ID
+     * @returns {Promise<string|null>}
+     */
+    async getStoredUserId() {
+        try {
+            return await Storage.getData('AUTH_USER_ID');
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * Get stored user metadata
+     * @returns {Promise<Object|null>}
+     */
+    async getStoredUserMetadata() {
+        try {
+            const metadata = await Storage.getData('AUTH_USER_METADATA');
+            return metadata ? JSON.parse(metadata) : null;
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * Get stored subscription data
+     * @returns {Promise<Object|null>}
+     */
+    async getStoredSubscription() {
+        try {
+            const subscription = await Storage.getData('AUTH_SUBSCRIPTION');
+            return subscription ? JSON.parse(subscription) : null;
+        } catch {
+            return null;
+        }
+    }
+}
+
+export default new Authentication();