apps-sdk 2.1.2 → 2.1.3

package/index.js

@@ -1,4 +1,4 @@
-import {NotificationsPush, Networking, Storage, Session, Utils, PayWallLogic, Rating, AdJust, TrackingTransparency, Voice, MixPanel, Adapty, HomeActions, Facebook, Firebase, Legal} from "./src/libraries";
+import {NotificationsPush, Networking, Storage, Session, Utils, PayWallLogic, Rating, AdJust, TrackingTransparency, Voice, MixPanel, Adapty, HomeActions, Facebook, Legal, Authentication} from "./src/libraries";
 // import PayWall from "./src/components/PayWall"; // DEPRECATED: Use SDK.adaptyOnboarding or SDK.adapty.showPaywall() instead
 import AdaptyOnboarding from "./src/components/AdaptyOnboarding";
 
@@ -65,4 +65,5 @@ export default {
     facebook:                    Facebook,
     firebase:                    Firebase,
     legal:                       Legal,
+    authentication:              Authentication,
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "apps-sdk",
-  "version": "2.1.2",
-  "description": "Apps SDK - Compatible with Expo SDK 54 + React 19 - create User pre url",
+  "version": "2.1.3",
+  "description": "Apps SDK - Compatible with Expo SDK 54 + React 19 - add rating flow, auth modules",
   "main": "index.js",
   "author": "ASD",
   "license": "ISC",

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();

package/src/libraries/Rating.js

@@ -1,65 +1,327 @@
 import * as StoreReview from 'expo-store-review';
+import { Platform } from 'react-native';
 import Storage from './Storage';
 
-const REVIEW_INTERVAL = 1000 * 60 * 60 * 24 * 7; // 7 días
+// ---------------------------------------------------------------------------
+// Storage keys
+// ---------------------------------------------------------------------------
+const STORAGE_KEYS = {
+    FIRST_AI_INTERACTION_DONE:    'RATING_FIRST_AI_INTERACTION_DONE',
+    USER_SENTIMENT_POSITIVE:      'RATING_USER_SENTIMENT_POSITIVE',
+    RATING_ATTEMPTS_COUNT:        'RATING_ATTEMPTS_COUNT',
+    FEEDBACK_SUBMITTED:           'RATING_FEEDBACK_SUBMITTED',
+    LAST_RATING_PROMPT_DATE:      'RATING_LAST_RATING_PROMPT_DATE',
+    DOWNLOAD_SHARE_PROMPT_SHOWN:  'RATING_DOWNLOAD_SHARE_PROMPT_SHOWN',
+    LOW_CREDITS_PROMPT_SHOWN:     'RATING_LOW_CREDITS_PROMPT_SHOWN',
+};
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const MAX_RATING_ATTEMPTS  = 2;      // Max native rating prompts shown lifetime
+const RATING_DELAY_MS      = 5000;   // Delay before showing prompt after AI response
+const LOW_CREDITS_THRESHOLD = 3;     // Credits level considered "low"
+
+// ---------------------------------------------------------------------------
+// Rating class
+// ---------------------------------------------------------------------------
 class Rating {
-    showRatingDialog = async (force = false) => {
+
+    // In-memory state (also persisted in storage)
+    _hasCompletedFirstInteraction = false;
+    _isShowingPrompt = false;
+
+    // UI callbacks — injected via configure()
+    _onShowSentimentPrompt = null;  // (source: string) => void
+    _onShowFeedbackForm    = null;  // () => void
+    _onTrackEvent          = null;  // (eventName: string, props: object) => void
+    _onSubmitFeedback      = null;  // (text: string) => Promise<void>  (optional app-level hook)
+
+    // -----------------------------------------------------------------------
+    // configure — call once on app startup (after initialize) with UI hooks
+    // -----------------------------------------------------------------------
+    configure = ({
+        onShowSentimentPrompt,
+        onShowFeedbackForm,
+        onTrackEvent,
+        onSubmitFeedback,
+    } = {}) => {
+        if (onShowSentimentPrompt) this._onShowSentimentPrompt = onShowSentimentPrompt;
+        if (onShowFeedbackForm)    this._onShowFeedbackForm    = onShowFeedbackForm;
+        if (onTrackEvent)          this._onTrackEvent          = onTrackEvent;
+        if (onSubmitFeedback)      this._onSubmitFeedback      = onSubmitFeedback;
+    }
+
+    // -----------------------------------------------------------------------
+    // initialize — load persisted state from storage
+    // -----------------------------------------------------------------------
+    initialize = async () => {
         try {
-            if (force || (await this.requestReviewIfNeeded())) {
-                if (await StoreReview.hasAction()) {
-                    if (await StoreReview.isAvailableAsync()) {
-                        await StoreReview.requestReview();
-                        return {
-                            success: true,
-                            shown: true,
-                            message: 'Review dialog shown successfully'
-                        };
-                    } else {
-                        return {
-                            success: false,
-                            shown: false,
-                            blocked: true,
-                            message: 'Review dialog not available (possibly blocked by OS)'
-                        };
-                    }
-                } else {
-                    return {
-                        success: false,
-                        shown: false,
-                        blocked: true,
-                        message: 'Store review not supported on this device'
-                    };
+            const hasInteracted = await Storage.getData(STORAGE_KEYS.FIRST_AI_INTERACTION_DONE);
+            this._hasCompletedFirstInteraction = hasInteracted === 'true';
+        } catch (error) {
+            console.error('[RatingFlow] Failed to initialize:', error);
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // onAIInteractionSuccess
+    // Called after every successful AI response.
+    // @param isUserInitiated — true if the user explicitly triggered the action
+    // -----------------------------------------------------------------------
+    onAIInteractionSuccess = async (isUserInitiated = false) => {
+        if (this._isShowingPrompt) return;
+
+        if (!this._hasCompletedFirstInteraction) {
+            // Only show on user-initiated interactions (not auto-generated intro/welcome)
+            if (!isUserInitiated) return;
+
+            await Storage.storeData(STORAGE_KEYS.FIRST_AI_INTERACTION_DONE, 'true');
+            this._hasCompletedFirstInteraction = true;
+
+            setTimeout(async () => {
+                const canShow = await this._checkBasicEligibility();
+                if (canShow) {
+                    await this._updateLastShownDate();
+                    this._showSentimentPrompt('ai_interaction');
+                }
+            }, RATING_DELAY_MS);
+            return;
+        }
+
+        const userSaidYes = await Storage.getData(STORAGE_KEYS.USER_SENTIMENT_POSITIVE);
+
+        if (userSaidYes === 'true') {
+            setTimeout(async () => {
+                const canShow    = await this._checkBasicEligibility();
+                const shownToday = await this._wasShownToday();
+                if (canShow && !shownToday && !this._isShowingPrompt) {
+                    await this._updateLastShownDate();
+                    this._trackEvent('rate_prompt_shown', { source: 'ai_interaction', type: 'direct_rating' });
+                    await this.triggerNativeRating();
+                }
+            }, RATING_DELAY_MS);
+        } else {
+            setTimeout(async () => {
+                const canShow    = await this._checkBasicEligibility();
+                const shownToday = await this._wasShownToday();
+                if (canShow && !shownToday && !this._isShowingPrompt) {
+                    await this._updateLastShownDate();
+                    this._showSentimentPrompt('ai_interaction');
                 }
-            } else {
-                console.log("Rating requestReviewIfNeeded not needed");
-                return {
-                    success: false,
-                    shown: false,
-                    tooSoon: true,
-                    message: 'Review request too soon (less than 7 days since last request)'
-                };
+            }, RATING_DELAY_MS);
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // onCreditsRunningLow
+    // Called after a successful action when credits are low.
+    // @param currentCredits — current credit count
+    // -----------------------------------------------------------------------
+    onCreditsRunningLow = async (currentCredits) => {
+        if (this._isShowingPrompt) return;
+        if (currentCredits > LOW_CREDITS_THRESHOLD) return;
+
+        const canShow = await this._checkBasicEligibility();
+        if (!canShow) return;
+
+        const shownToday = await this._wasShownToday();
+        if (shownToday) return;
+
+        const userSaidYes = await Storage.getData(STORAGE_KEYS.USER_SENTIMENT_POSITIVE);
+        if (userSaidYes === 'true') {
+            await this._updateLastShownDate();
+            this._trackEvent('rate_prompt_shown', { source: 'credits_low', type: 'direct_rating' });
+            await this.triggerNativeRating();
+        } else {
+            const alreadyShown = await Storage.getData(STORAGE_KEYS.LOW_CREDITS_PROMPT_SHOWN);
+            if (alreadyShown === 'true') return;
+            await Storage.storeData(STORAGE_KEYS.LOW_CREDITS_PROMPT_SHOWN, 'true');
+            await this._updateLastShownDate();
+            this._showSentimentPrompt('credits_low');
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // onResultDownloadedOrShared
+    // Called when the user downloads or shares an AI result.
+    // @param actionType — 'download' | 'share'
+    // -----------------------------------------------------------------------
+    onResultDownloadedOrShared = async (actionType) => {
+        if (this._isShowingPrompt) return;
+
+        const canShow = await this._checkBasicEligibility();
+        if (!canShow) return;
+
+        const shownToday = await this._wasShownToday();
+        if (shownToday) return;
+
+        const userSaidYes = await Storage.getData(STORAGE_KEYS.USER_SENTIMENT_POSITIVE);
+        if (userSaidYes === 'true') {
+            await this._updateLastShownDate();
+            this._trackEvent('rate_prompt_shown', { source: `result_${actionType}`, type: 'direct_rating' });
+            await this.triggerNativeRating();
+        } else {
+            const alreadyShown = await Storage.getData(STORAGE_KEYS.DOWNLOAD_SHARE_PROMPT_SHOWN);
+            if (alreadyShown === 'true') return;
+            await Storage.storeData(STORAGE_KEYS.DOWNLOAD_SHARE_PROMPT_SHOWN, 'true');
+            await this._updateLastShownDate();
+            this._showSentimentPrompt(`result_${actionType}`);
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // triggerNativeRating — calls StoreReview.requestReview()
+    // -----------------------------------------------------------------------
+    triggerNativeRating = async () => {
+        this._trackEvent('native_rating_prompt_called', { platform: Platform.OS });
+        try {
+            const attemptsStr = await Storage.getData(STORAGE_KEYS.RATING_ATTEMPTS_COUNT);
+            const newAttempts = (attemptsStr ? parseInt(attemptsStr, 10) : 0) + 1;
+            await Storage.storeData(STORAGE_KEYS.RATING_ATTEMPTS_COUNT, String(newAttempts));
+            await StoreReview.requestReview();
+        } catch (error) {
+            console.error('[RatingFlow] Rating request failed:', error);
+            this._trackEvent('native_rating_api_error', { platform: Platform.OS, error: String(error) });
+        } finally {
+            this._isShowingPrompt = false;
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // onUserRespondedYes — call from the sentiment prompt YES handler
+    // -----------------------------------------------------------------------
+    onUserRespondedYes = async () => {
+        this._trackEvent('rate_prompt_response', { response: 'yes' });
+        await Storage.storeData(STORAGE_KEYS.USER_SENTIMENT_POSITIVE, 'true');
+        await this.triggerNativeRating();
+    }
+
+    // -----------------------------------------------------------------------
+    // onUserRespondedNo — call from the sentiment prompt NO handler
+    // -----------------------------------------------------------------------
+    onUserRespondedNo = () => {
+        this._trackEvent('rate_prompt_response', { response: 'no' });
+        this._showFeedbackForm();
+    }
+
+    // -----------------------------------------------------------------------
+    // submitFeedback — call when the user submits written feedback
+    // @param feedbackText — the feedback string
+    // -----------------------------------------------------------------------
+    submitFeedback = async (feedbackText) => {
+        try {
+            this._trackEvent('feedback_submitted', { feedback_text: feedbackText });
+            await Storage.storeData(STORAGE_KEYS.FEEDBACK_SUBMITTED, 'true');
+            if (this._onSubmitFeedback) await this._onSubmitFeedback(feedbackText);
+        } catch (error) {
+            console.error('[RatingFlow] Failed to submit feedback:', error);
+            throw error;
+        } finally {
+            this._isShowingPrompt = false;
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // onFeedbackCanceled — call when the user dismisses the feedback form
+    // -----------------------------------------------------------------------
+    onFeedbackCanceled = () => {
+        this._trackEvent('feedback_canceled');
+        this._isShowingPrompt = false;
+    }
+
+    // -----------------------------------------------------------------------
+    // reset — clears all persisted rating state (for debugging/testing)
+    // -----------------------------------------------------------------------
+    reset = async () => {
+        await Promise.all(Object.values(STORAGE_KEYS).map(key => Storage.removeData(key)));
+        this._hasCompletedFirstInteraction = false;
+        this._isShowingPrompt = false;
+    }
+
+    // -----------------------------------------------------------------------
+    // Legacy: showRatingDialog — kept for backwards compatibility
+    // -----------------------------------------------------------------------
+    showRatingDialog = async (force = false) => {
+        try {
+            if (force) {
+                await this.triggerNativeRating();
+                return { success: true, shown: true };
             }
+            const canShow = await this._checkBasicEligibility();
+            if (!canShow) return { success: false, shown: false, tooSoon: true };
+            await this.triggerNativeRating();
+            return { success: true, shown: true };
+        } catch (error) {
+            console.error('[RatingFlow] showRatingDialog error:', error);
+            return { success: false, shown: false, error: true, message: error.message };
+        }
+    }
+
+    // =======================================================================
+    // Private helpers
+    // =======================================================================
+
+    _checkBasicEligibility = async () => {
+        try {
+            const isAvailable = await StoreReview.isAvailableAsync();
+            if (!isAvailable) return false;
+
+            const feedbackSubmitted = await Storage.getData(STORAGE_KEYS.FEEDBACK_SUBMITTED);
+            if (feedbackSubmitted === 'true') return false;
+
+            const attemptsStr = await Storage.getData(STORAGE_KEYS.RATING_ATTEMPTS_COUNT);
+            const attempts = attemptsStr ? parseInt(attemptsStr, 10) : 0;
+            if (attempts >= MAX_RATING_ATTEMPTS) return false;
+
+            return true;
         } catch (error) {
-            console.log("Error en requestReview", error);
-            return {
-                success: false,
-                shown: false,
-                error: true,
-                message: error.message
-            };
+            console.error('[RatingFlow] Error checking basic eligibility:', error);
+            return false;
         }
     }
 
-    requestReviewIfNeeded = async () => {
-        const lastReviewRequestString = await Storage.getData('lastReviewRequest');
-        const lastReviewRequest = lastReviewRequestString ? Number(lastReviewRequestString) : 0;
-        const now = Date.now();
-        if (now - lastReviewRequest > REVIEW_INTERVAL) {
-            const available = await StoreReview.isAvailableAsync();
-            if (available) {
-                await StoreReview.requestReview();
-                await Storage.storeData('lastReviewRequest', now.toString());
+    _wasShownToday = async () => {
+        try {
+            const lastShownDate = await Storage.getData(STORAGE_KEYS.LAST_RATING_PROMPT_DATE);
+            if (lastShownDate) {
+                const lastDate = new Date(lastShownDate);
+                const now = new Date();
+                return lastDate.toDateString() === now.toDateString();
             }
+            return false;
+        } catch (error) {
+            console.error('[RatingFlow] Error checking last shown date:', error);
+            return false;
+        }
+    }
+
+    _updateLastShownDate = async () => {
+        await Storage.storeData(STORAGE_KEYS.LAST_RATING_PROMPT_DATE, new Date().toISOString());
+    }
+
+    _showSentimentPrompt = (source) => {
+        this._isShowingPrompt = true;
+        this._trackEvent('rate_prompt_shown', { source: source || 'ai_interaction' });
+        if (this._onShowSentimentPrompt) {
+            this._onShowSentimentPrompt(source);
+        } else {
+            console.warn('[RatingFlow] No sentiment prompt handler configured. Call AppsSDK.rating.configure().');
+        }
+    }
+
+    _showFeedbackForm = () => {
+        this._trackEvent('feedback_screen_shown');
+        if (this._onShowFeedbackForm) {
+            this._onShowFeedbackForm();
+        } else {
+            console.warn('[RatingFlow] No feedback form handler configured. Call AppsSDK.rating.configure().');
+        }
+    }
+
+    _trackEvent = (eventName, properties = {}) => {
+        if (this._onTrackEvent) {
+            this._onTrackEvent(eventName, { ...properties, timestamp: new Date().toISOString() });
         }
     }
 }

package/src/libraries/index.js

@@ -14,3 +14,4 @@ export { default as HomeActions }           from './QuickActions';
 export { default as Facebook }              from './Facebook';
 export { default as Firebase }              from './Firebase';
 export { default as Legal }                 from './Legal';
+export { default as Authentication }        from './Authentication';

package/types/index.d.ts

@@ -37,6 +37,10 @@ declare module 'apps-sdk' {
         init(): Promise<void>;
         setDebugMode(debugMode: boolean): void;
         setConfigEndpoint(endpoint: string): void;
+        setUserCreateEndpoint(endpoint: string): void;
+        setBaseUrl(baseUrl: string): void;
+        getCredits(webappUrl: string, websiteId: string): Promise<number>;
+        getWebappBasePayload(websiteId: string, additionalData?: any): any;
         initSession(): Promise<void>;
         storeSessionStructure(): Promise<void>;
         checkFirstOpen(): Promise<void>;
@@ -119,8 +123,42 @@ declare module 'apps-sdk' {
         isSpecialEvent(eventKeyword: string): boolean;
     }
 
+    export interface RatingConfigOptions {
+        /** Called when the sentiment prompt ("Are you enjoying the app?") should be shown. */
+        onShowSentimentPrompt: (source: string) => void;
+        /** Called when the feedback form should be shown (user said NO). */
+        onShowFeedbackForm: () => void;
+        /** Called to track analytics events. */
+        onTrackEvent: (eventName: string, properties: Record<string, any>) => void;
+        /** Optional: called after feedback text is submitted. */
+        onSubmitFeedback?: (feedbackText: string) => Promise<void>;
+    }
+
     export class Rating {
-        showRatingDialog(force?: boolean): Promise<void>;
+        /** Register UI callbacks. Call once on app startup after initialize(). */
+        configure(options: RatingConfigOptions): void;
+        /** Load persisted state from storage. Call on app startup. */
+        initialize(): Promise<void>;
+        /** Trigger rating flow after a successful AI interaction. */
+        onAIInteractionSuccess(isUserInitiated?: boolean): Promise<void>;
+        /** Trigger rating flow when credits are running low. */
+        onCreditsRunningLow(currentCredits: number): Promise<void>;
+        /** Trigger rating flow after user downloads or shares a result. */
+        onResultDownloadedOrShared(actionType: 'download' | 'share'): Promise<void>;
+        /** Directly call StoreReview.requestReview(). */
+        triggerNativeRating(): Promise<void>;
+        /** Call this when the user taps YES on the sentiment prompt. */
+        onUserRespondedYes(): Promise<void>;
+        /** Call this when the user taps NO on the sentiment prompt. */
+        onUserRespondedNo(): void;
+        /** Submit written feedback text. */
+        submitFeedback(feedbackText: string): Promise<void>;
+        /** Call when the user dismisses the feedback form without submitting. */
+        onFeedbackCanceled(): void;
+        /** Reset all persisted rating state (for debugging/testing). */
+        reset(): Promise<void>;
+        /** @deprecated Legacy method — use the new flow methods instead. */
+        showRatingDialog(force?: boolean): Promise<{ success: boolean; shown: boolean; [key: string]: any }>;
     }
 
     export class NotificationsPush {