apps-sdk 2.1.3 → 2.1.5

package/config.js

@@ -26,6 +26,7 @@ const config = {
 
     WEBAPP_PATHS: {
         GET_CREDITS: "/user/get-credits",
+        CHECK_SUBS: "/user/check-subs",
     },
 
     LEGAL_PATHS: {

package/index.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "apps-sdk",
-  "version": "2.1.3",
-  "description": "Apps SDK - Compatible with Expo SDK 54 + React 19 - add rating flow, auth modules",
+  "version": "2.1.5",
+  "description": "Apps SDK - Compatible with Expo SDK 54 + React 19 - add generic method checksubscription to check if user has active subscription in webapp",
   "main": "index.js",
   "author": "ASD",
   "license": "ISC",

package/src/libraries/Session.js

@@ -284,6 +284,37 @@ class Session {
             return 0;
         }
     }
+
+    checkSubscriptionWebapp = async (webappUrl, websiteId) => {
+        config.DEBUG_MODE && console.debug("checkSubscriptionWebapp");
+        
+        try {
+            const endpoint = `${webappUrl}${config.WEBAPP_PATHS.CHECK_SUBS}`;
+            const payload = this.getWebappBasePayload(websiteId);
+            
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+            });
+            
+            const data = await response.json();
+            config.DEBUG_MODE && console.debug("checkSubscriptionWebapp - result: ", data);
+            
+            if (data?.success && data?.data?.[0]) {
+                const subData = data.data[0];
+                await this.setIsSubscribed(subData.subscription_active);
+                await this.setSubscriptionData(subData);
+                
+                return subData;
+            }
+            
+            return null;
+        } catch (error) {
+            console.error('[SDK] checkSubscriptionWebapp error:', error);
+            return null;
+        }
+    }
 }
 
 export default new Session();

package/types/index.d.ts

@@ -40,6 +40,7 @@ declare module 'apps-sdk' {
         setUserCreateEndpoint(endpoint: string): void;
         setBaseUrl(baseUrl: string): void;
         getCredits(webappUrl: string, websiteId: string): Promise<number>;
+        checkSubscriptionWebapp(webappUrl: string, websiteId: string): Promise<any>;
         getWebappBasePayload(websiteId: string, additionalData?: any): any;
         initSession(): Promise<void>;
         storeSessionStructure(): Promise<void>;
@@ -343,6 +344,269 @@ declare module 'apps-sdk' {
         setUserProperty(name: string, value: string): Promise<void>;
     }
 
+    // ─── Authentication ────────────────────────────────────────────────────────
+
+    export interface AuthApiResult<T = any> {
+        success: boolean;
+        data?: T;
+        error?: string;
+        code?: number;
+        message?: string;
+        raw?: any;
+    }
+
+    export interface AuthLoginPayload {
+        /** Email or username */
+        login?: string;
+        /** Credential (alias for login) */
+        credential?: string;
+        /** Password */
+        password: string;
+        /** Optional website ID (defaults to config value) */
+        websiteid?: string;
+    }
+
+    export interface AuthRegisterPayload {
+        /** Email or username */
+        login?: string;
+        /** Email (alias for login) */
+        email?: string;
+        /** Password */
+        password: string;
+        /** Optional website ID (defaults to config value) */
+        websiteid?: string;
+    }
+
+    export interface AuthRegisterAndLinkPayload {
+        email: string;
+        password: string;
+    }
+
+    export interface AuthLinkUserPayload {
+        /** Web user ID */
+        user_id: string;
+        /** Mobile app user ID */
+        app_user_id: string;
+    }
+
+    export interface AuthCheckLinkPayload {
+        user_id: string;
+        app_user_id: string;
+    }
+
+    export interface AuthCheckSubscriptionPayload {
+        user_id: string;
+        app_user_id: string;
+    }
+
+    export interface AuthValidatePhonePayload {
+        phoneNumber: string;
+        countryCode: string;
+    }
+
+    export interface AuthRequestPasswordResetPayload {
+        credential: string;
+    }
+
+    export interface AuthVerifyResetCodePayload {
+        code: string;
+    }
+
+    export interface AuthResetPasswordPayload {
+        resetToken: string;
+        newPassword: string;
+    }
+
+    export interface AuthResendCodePayload {
+        credential: string;
+    }
+
+    export interface AuthValidateQrCodePayload {
+        qrData: string;
+    }
+
+    export interface AuthLinkWithQrCodePayload {
+        user_id: string;
+    }
+
+    export interface AuthUserData {
+        us_id: string | number;
+        us_login?: string;
+        login?: string;
+        metadata?: Record<string, any> | any[];
+        subscription_data?: AuthSubscriptionData;
+        success?: number;
+    }
+
+    export interface AuthSubscriptionData {
+        subscription_active?: boolean;
+        [key: string]: any;
+    }
+
+    export interface AuthLinkedUserData {
+        success: number;
+        linked: boolean;
+        items?: AuthUserData[];
+    }
+
+    export interface AuthRegisterAndLinkResult {
+        success: boolean;
+        user?: AuthUserData;
+        linked?: boolean;
+        error?: string;
+        code?: number;
+    }
+
+    export interface AuthQrValidationData {
+        valid: boolean;
+        user_id?: string;
+    }
+
+    export interface AuthQrLinkData {
+        linked: boolean;
+        message?: string;
+        subscriptionActive?: boolean;
+    }
+
+    export interface AuthCallApiOptions {
+        retries?: number;
+        timeoutMs?: number;
+        silent?: boolean;
+    }
+
+    export class Authentication {
+        AUTH_API_BASE_URL: string;
+        USER_API_BASE_URL: string;
+        CHATCONNECT_API_BASE_URL: string;
+
+        /** Get website ID from config */
+        getWebsiteId(): string;
+
+        /** Get app user ID from session */
+        getAppUserId(): string;
+
+        /**
+         * Generic API call helper with retry logic.
+         */
+        callApi(url: string, payload: object, opts?: AuthCallApiOptions): Promise<AuthApiResult>;
+
+        /**
+         * Login with credentials.
+         * POST /auth/auth-user
+         */
+        login(payload: AuthLoginPayload): Promise<AuthApiResult<AuthUserData>>;
+
+        /**
+         * Register a new user account.
+         * POST /chatconnect/create-user
+         */
+        register(payload: AuthRegisterPayload): Promise<AuthApiResult<{ user: AuthUserData }>>;
+
+        /**
+         * Complete registration flow: create-user → link-user.
+         */
+        registerAndLinkAccount(payload: AuthRegisterAndLinkPayload): Promise<AuthRegisterAndLinkResult>;
+
+        /**
+         * Link a user account.
+         * POST /user/link
+         */
+        linkUser(payload: AuthLinkUserPayload): Promise<AuthApiResult<AuthLinkedUserData>>;
+
+        /**
+         * Fetch authenticated user profile using stored credentials.
+         */
+        fetchUserProfile(): Promise<AuthApiResult<AuthUserData>>;
+
+        /**
+         * Check if user account is linked (using stored data).
+         */
+        isAccountLinked(): Promise<boolean>;
+
+        /**
+         * Get stored auth user login (email).
+         */
+        getStoredUserLogin(): Promise<string | null>;
+
+        /**
+         * Check if user is linked.
+         * POST /user/check-link
+         */
+        checkLink(payload: AuthCheckLinkPayload): Promise<AuthApiResult>;
+
+        /**
+         * Check user subscription status.
+         * POST /user/check-subs
+         */
+        checkSubscription(payload: AuthCheckSubscriptionPayload): Promise<AuthApiResult>;
+
+        /**
+         * Check if a credential exists (stub for backward compatibility).
+         */
+        checkCredential(payload: { credentialType: string; [key: string]: any }): Promise<AuthApiResult<{ exists: boolean; credentialType: string; requiresPhone: boolean }>>;
+
+        /**
+         * Validate phone number (client-side).
+         */
+        validatePhone(payload: AuthValidatePhonePayload): Promise<AuthApiResult<{ valid: boolean; formattedPhone?: string }>>;
+
+        /**
+         * Request password reset (stub).
+         */
+        requestPasswordReset(payload: AuthRequestPasswordResetPayload): Promise<AuthApiResult<{ sent: boolean; destination: string; expiresIn: number }>>;
+
+        /**
+         * Verify reset code (stub).
+         */
+        verifyResetCode(payload: AuthVerifyResetCodePayload): Promise<AuthApiResult<{ valid: boolean; resetToken: string }>>;
+
+        /**
+         * Reset password (stub).
+         */
+        resetPassword(payload: AuthResetPasswordPayload): Promise<AuthApiResult<{ success: boolean; message: string }>>;
+
+        /**
+         * Resend verification code (stub).
+         */
+        resendCode(payload: AuthResendCodePayload): Promise<AuthApiResult<{ sent: boolean; canResendAt: string }>>;
+
+        /**
+         * Validate QR code data.
+         */
+        validateQrCode(payload: AuthValidateQrCodePayload): Promise<AuthApiResult<AuthQrValidationData>>;
+
+        /**
+         * Link account using QR code.
+         * POST /user/link
+         */
+        linkWithQrCode(payload: AuthLinkWithQrCodePayload): Promise<AuthApiResult<AuthQrLinkData>>;
+
+        /**
+         * Logout current user (clears stored auth data).
+         */
+        logout(): Promise<AuthApiResult<{ success: boolean }>>;
+
+        /**
+         * Check if user is currently authenticated (has stored user ID).
+         */
+        isAuthenticated(): Promise<boolean>;
+
+        /**
+         * Get stored user ID.
+         */
+        getStoredUserId(): Promise<string | null>;
+
+        /**
+         * Get stored user metadata.
+         */
+        getStoredUserMetadata(): Promise<Record<string, any> | null>;
+
+        /**
+         * Get stored subscription data.
+         */
+        getStoredSubscription(): Promise<AuthSubscriptionData | null>;
+    }
+
     export class AppsSDK {
         initializePushNotifications(): Promise<string>;
     }
@@ -361,13 +625,16 @@ declare module 'apps-sdk' {
         mixpanel            : MixPanel;
         tracking            : TrackingTransparency;
         paywallLogic        : PayWallLogic;
+        /** @deprecated Use `notifications` instead */
         notificationsPush   : NotificationsPush;
+        notifications       : NotificationsPush;
         voice               : Voice;
         adapty              : Adapty;
         homeActions         : HomeActions;
         facebook            : Facebook;
         firebase            : Firebase;
         legal               : Legal;
+        authentication      : Authentication;
     }
 
     const Core: AppsSDK;