chore: entitlements refresh logic every 10 minutes for promo end detection

Author: abose

src/services/login-service.js

@@ -27,7 +27,10 @@ define(function (require, exports, module) {
     require("./setup-login-service"); // this adds loginService to KernalModeTrust
     require("./promotions");
 
+    const Metrics = require("utils/Metrics");
+
     const MS_IN_DAY = 10 * 24 * 60 * 60 * 1000;
+    const TEN_MINUTES = 10 * 60 * 1000;
 
     const KernalModeTrust = window.KernalModeTrust;
     if(!KernalModeTrust){
@@ -43,6 +46,25 @@ define(function (require, exports, module) {
     // Cached entitlements data
     let cachedEntitlements = null;
 
+    // Last recorded state for entitlements monitoring
+    let lastRecordedState = null;
+
+    // Debounced trigger for entitlements changed
+    let entitlementsChangedTimer = null;
+
+    function _debounceEntitlementsChanged() {
+        if (entitlementsChangedTimer) {
+            // already scheduled, skip
+            return;
+        }
+
+        entitlementsChangedTimer = setTimeout(() => {
+            LoginService.trigger(EVENT_ENTITLEMENTS_CHANGED);
+            entitlementsChangedTimer = null;
+        }, 1000); // atmost 1 entitlement changed event will be triggered in a second
+    }
+
+
     /**
      * Get entitlements from API or cache
      * Returns null if user is not logged in
@@ -96,7 +118,7 @@ define(function (require, exports, module) {
 
                     // Trigger event if entitlements changed
                     if (entitlementsChanged) {
-                        LoginService.trigger(EVENT_ENTITLEMENTS_CHANGED, result);
+                        _debounceEntitlementsChanged();
                     }
 
                     return cachedEntitlements;
@@ -116,12 +138,139 @@ define(function (require, exports, module) {
     function clearEntitlements() {
         if (cachedEntitlements) {
             cachedEntitlements = null;
+            _debounceEntitlementsChanged();
+        }
+    }
+
+    /**
+     * Check if any validTill time has expired
+     */
+    function validTillExpired(entitlements, lastRecordedEntitlement) {
+        if (!entitlements) {
+            return null;
+        }
+
+        const now = Date.now();
+
+        function isNewlyExpired(validTill, lastValidTill) {
+            return (
+                validTill &&
+                validTill < now &&                      // expired now
+                (!lastValidTill || lastValidTill >= now) // but wasn't expired before
+            );
+        }
+
+        // Check plan validTill
+        if (entitlements.plan) {
+            const validTill = entitlements.plan.validTill;
+            const lastValidTill = (lastRecordedEntitlement && lastRecordedEntitlement.plan)
+                ? lastRecordedEntitlement.plan.validTill
+                : null;
+
+            if (isNewlyExpired(validTill, lastValidTill)) {
+                return entitlements.plan.name || brackets.config.main_pro_plan;
+            }
+        }
+
+        // Check entitlements validTill
+        if (entitlements.entitlements) {
+            for (const key in entitlements.entitlements) {
+                const entitlement = entitlements.entitlements[key];
+                if (!entitlement) {
+                    continue;
+                }
+
+                const validTill = entitlement.validTill;
+                const lastValidTill = (lastRecordedEntitlement &&
+                    lastRecordedEntitlement.entitlements &&
+                    lastRecordedEntitlement.entitlements[key])
+                    ? lastRecordedEntitlement.entitlements[key].validTill
+                    : null;
+
+                if (isNewlyExpired(validTill, lastValidTill)) {
+                    return key;
+                }
+            }
+        }
+
+        return null;
+    }
+
+
+    /**
+     * Check if entitlements have changed from last recorded state
+     */
+    function haveEntitlementsChanged(current, last) {
+        if (!last && !current) {
+            return false;
+        }
+        if ((!last && current) || (!current && last)) {
+            return true;
+        }
+        if ((!last.entitlements && current.entitlements) || (current.entitlements && !last.entitlements)) {
+            return true;
+        }
+
+        // Check paidSubscriber changes
+        const currentPaidSub = current.plan && current.plan.paidSubscriber;
+        const lastPaidSub = last.plan && last.plan.paidSubscriber;
+        if (currentPaidSub !== lastPaidSub) {
+            return true;
+        }
+
+        // Check plan name changes
+        const currentPlanName = current.plan && current.plan.name;
+        const lastPlanName = last.plan && last.plan.name;
+        if (currentPlanName !== lastPlanName) {
+            return true;
+        }
 
-            // Trigger event when entitlements are cleared
-            if (LoginService.trigger) {
-                LoginService.trigger(EVENT_ENTITLEMENTS_CHANGED, null);
+        // Check entitlement activations
+        if (current.entitlements && last.entitlements) {
+            for (const key of Object.keys(current.entitlements)) {
+                const currentActivated = current.entitlements[key] && current.entitlements[key].activated;
+                const lastActivated = last.entitlements[key] && last.entitlements[key].activated;
+                if (currentActivated !== lastActivated) {
+                    return true;
+                }
             }
         }
+
+        return false;
+    }
+
+    /**
+     * Start the 10-minute interval timer for monitoring entitlements
+     */
+    function startEntitlementsMonitor() {
+        setInterval(async () => {
+            try {
+                const current = await getEffectiveEntitlements(false); // Get effective entitlements
+
+                // Check if we need to refresh
+                const expiredPlanName = validTillExpired(current, lastRecordedState);
+                const hasChanged = haveEntitlementsChanged(current, lastRecordedState);
+
+                if (expiredPlanName || hasChanged) {
+                    console.log(`Entitlements monitor detected changes, Expired: ${expiredPlanName},` +
+                        `changed: ${hasChanged} refreshing...`);
+                    Metrics.countEvent(Metrics.EVENT_TYPE.PRO, "entRefresh",
+                        expiredPlanName ? "exp_"+expiredPlanName : "changed");
+                    await getEffectiveEntitlements(true); // Force refresh
+                    // if not logged in, the getEffectiveEntitlements will not trigger change even if some trial
+                    // entitlements changed. so we trigger a change anyway here. The debounce will take care of
+                    // multi fire and we are ok with multi fire 1 second apart.
+                    _debounceEntitlementsChanged();
+                }
+
+                // Update last recorded state
+                lastRecordedState = current;
+            } catch (error) {
+                console.error('Entitlements monitor error:', error);
+            }
+        }, TEN_MINUTES);
+
+        console.log('Entitlements monitor started (10-minute interval)');
     }
 
     /**
@@ -197,7 +346,8 @@ define(function (require, exports, module) {
      * @example
      * // Listen for entitlements changes
      * const LoginService = window.KernelModeTrust.loginService;
-     * LoginService.on(LoginService.EVENT_ENTITLEMENTS_CHANGED, (entitlements) => {
+     * LoginService.on(LoginService.EVENT_ENTITLEMENTS_CHANGED, async() => {
+     *   const entitlements = await LoginService.getEffectiveEntitlements();
      *   console.log('Entitlements changed:', entitlements);
      *   // Update UI based on new entitlements
      * });
@@ -278,4 +428,7 @@ define(function (require, exports, module) {
     LoginService.getEffectiveEntitlements = getEffectiveEntitlements;
     LoginService.clearEntitlements = clearEntitlements;
     LoginService.EVENT_ENTITLEMENTS_CHANGED = EVENT_ENTITLEMENTS_CHANGED;
+
+    // Start the entitlements monitor timer
+    startEntitlementsMonitor();
 });

src/services/promotions.js

@@ -292,8 +292,8 @@ define(function (require, exports, module) {
 
         // Also trigger entitlements changed event since effective entitlements have changed
         // This allows UI components to update based on the new trial status
-        const effectiveEntitlements = await LoginService.getEffectiveEntitlements();
-        LoginService.trigger(LoginService.EVENT_ENTITLEMENTS_CHANGED, effectiveEntitlements);
+        await LoginService.getEffectiveEntitlements();
+        LoginService.trigger(LoginService.EVENT_ENTITLEMENTS_CHANGED);
     }
 
     function _isAnyDialogsVisible() {