Refactored hasActiveOffer and _getActiveDiscount to share common logic

ghost/core/core/server/services/members/members-api/services/next-payment-calculator.js

@@ -1,3 +1,5 @@
+const getDiscountWindow = require('../utils/get-discount-window');
+
 /**
  * @typedef {import('../../../../services/offers/application/offer-mapper').OfferDTO} OfferDTO
  */
@@ -101,42 +103,15 @@ class NextPaymentCalculator {
      * @returns {ActiveDiscount|null}
      */
     _getActiveDiscount(subscription, offer) {
-        // Offers are based on a Stripe coupon, with a discount_start / discount_end
-        if (subscription.discount_start) {
-            return {
-                start: subscription.discount_start,
-                end: subscription.discount_end
-            };
-        }
-
-        // Backportability for old signup offers without discount_start / discount_end
-        if (offer.redemption_type !== 'signup') {
+        // Skip if there's no Stripe discount data and the offer isn't eligible for legacy backport:
+        // - signup offers are backported for legacy data without discount_start
+        // - retention offers are excluded because they were introduced after discount_start
+        //   was available, so missing discount_start means there's no active discount
+        if (!subscription.discount_start && offer.redemption_type !== 'signup') {
             return null;
         }
 
-        // Signup offers with once have already been applied to first payment
-        if (offer.duration === 'once') {
-            return null;
-        }
-
-        // Signup offer with forever don't expire
-        if (offer.duration === 'forever') {
-            return {start: subscription.start_date, end: null};
-        }
-
-        // Signup repeating offer expire after start_date + duration_in_months
-        if (offer.duration === 'repeating' && offer.duration_in_months > 0) {
-            const end = new Date(subscription.start_date);
-            end.setUTCMonth(end.getUTCMonth() + offer.duration_in_months);
-
-            if (new Date() >= end) {
-                return null;
-            }
-
-            return {start: subscription.start_date, end};
-        }
-
-        return null;
+        return getDiscountWindow(subscription, offer);
     }
 
     /**

ghost/core/core/server/services/members/members-api/utils/get-discount-window.js

@@ -0,0 +1,48 @@
+/**
+ * Computes the discount window for a subscription based on available data.
+ * Returns {start, end} if a discount window can be determined, null otherwise.
+ *
+ * Handles two data paths:
+ * 1. Stripe coupon discounts (post-6.16) - uses discount_start / discount_end
+ * 2. Legacy fallback - computes from offer duration and start_date
+ *
+ * @param {object} subscription - plain object with: discount_start, discount_end, start_date
+ * @param {object|null} offer - offer data with: duration, duration_in_months.
+ *   Pass null to skip offer-dependent checks.
+ * @returns {{start: *, end: *}|null}
+ */
+module.exports = function getDiscountWindow(subscription, offer) {
+    // Stripe coupon discount (post-6.16 data)
+    if (subscription.discount_start) {
+        return {
+            start: subscription.discount_start,
+            end: subscription.discount_end || null
+        };
+    }
+
+    // Legacy fallback: compute window from offer duration
+    if (!offer) {
+        return null;
+    }
+
+    if (offer.duration === 'once') {
+        return null;
+    }
+
+    if (offer.duration === 'forever') {
+        return {start: subscription.start_date, end: null};
+    }
+
+    if (offer.duration === 'repeating' && offer.duration_in_months > 0) {
+        const end = new Date(subscription.start_date);
+        end.setUTCMonth(end.getUTCMonth() + offer.duration_in_months);
+
+        if (new Date() >= end) {
+            return null;
+        }
+
+        return {start: subscription.start_date, end};
+    }
+
+    return null;
+};

ghost/core/core/server/services/members/members-api/utils/has-active-offer.js

@@ -1,3 +1,5 @@
+const getDiscountWindow = require('./get-discount-window');
+
 /**
  * Determines if a subscription currently has an active offer.
  * Uses discount_start/discount_end (synced from Stripe) when available,
@@ -8,16 +10,21 @@
  * @returns {Promise<boolean>}
  */
 module.exports = async function hasActiveOffer(subscriptionModel, offersAPI) {
-    const discountStart = subscriptionModel.get('discount_start');
-    const discountEnd = subscriptionModel.get('discount_end');
-    const trialEndAt = subscriptionModel.get('trial_end_at');
+    const subscriptionData = {
+        discount_start: subscriptionModel.get('discount_start'),
+        discount_end: subscriptionModel.get('discount_end'),
+        start_date: subscriptionModel.get('start_date')
+    };
 
     // Check for active Stripe discount (post-6.16 data)
-    if (discountStart) {
-        return !discountEnd || new Date(discountEnd) > new Date();
+    // discount_start takes precedence over trial and legacy fallback
+    const discountWindow = getDiscountWindow(subscriptionData, null);
+    if (discountWindow) {
+        return !discountWindow.end || new Date(discountWindow.end) > new Date();
     }
 
     // Check for active trial (trial offers)
+    const trialEndAt = subscriptionModel.get('trial_end_at');
     if (trialEndAt && new Date(trialEndAt) > new Date()) {
         return true;
     }
@@ -35,26 +42,14 @@ module.exports = async function hasActiveOffer(subscriptionModel, offersAPI) {
             return false;
         }
 
-        if (offer.duration === 'forever') {
-            return true;
-        }
-
-        if (offer.duration === 'once') {
-            return false; // once = already applied and expired
+        const legacyWindow = getDiscountWindow(subscriptionData, offer);
+        if (legacyWindow) {
+            return !legacyWindow.end || new Date(legacyWindow.end) > new Date();
         }
 
-        if (offer.duration === 'repeating' && offer.duration_in_months > 0) {
-            const startDate = new Date(subscriptionModel.get('start_date'));
-            const end = new Date(startDate);
-
-            end.setUTCMonth(end.getUTCMonth() + offer.duration_in_months);
-
-            return new Date() < end;
-        }
+        return false;
     } catch (e) {
         // If we can't look up the offer, err on the side of blocking
         return true;
     }
-
-    return false;
 };

ghost/core/test/unit/server/services/members/members-api/utils/get-discount-window.test.js

@@ -0,0 +1,133 @@
+const assert = require('node:assert/strict');
+const getDiscountWindow = require('../../../../../../../core/server/services/members/members-api/utils/get-discount-window');
+
+describe('getDiscountWindow', function () {
+    function createSubscription(overrides = {}) {
+        return {
+            discount_start: null,
+            discount_end: null,
+            start_date: new Date('2025-01-01T00:00:00.000Z'),
+            ...overrides
+        };
+    }
+
+    // Stripe coupon discount (post-6.16 data)
+
+    describe('stripe coupon discount', function () {
+        it('returns window when discount_start is present with discount_end', function () {
+            const discountStart = new Date('2025-05-01T00:00:00.000Z');
+            const discountEnd = new Date('2025-11-01T00:00:00.000Z');
+            const subscription = createSubscription({
+                discount_start: discountStart,
+                discount_end: discountEnd
+            });
+
+            const result = getDiscountWindow(subscription, null);
+
+            assert.deepEqual(result, {start: discountStart, end: discountEnd});
+        });
+
+        it('returns window with null end for forever discounts', function () {
+            const discountStart = new Date('2025-05-01T00:00:00.000Z');
+            const subscription = createSubscription({
+                discount_start: discountStart,
+                discount_end: null
+            });
+
+            const result = getDiscountWindow(subscription, null);
+
+            assert.deepEqual(result, {start: discountStart, end: null});
+        });
+
+        it('returns window even when discount_end is in the past (trusts Stripe data)', function () {
+            const discountStart = new Date('2025-01-01T00:00:00.000Z');
+            const discountEnd = new Date('2025-06-01T00:00:00.000Z');
+            const subscription = createSubscription({
+                discount_start: discountStart,
+                discount_end: discountEnd
+            });
+
+            const result = getDiscountWindow(subscription, null);
+
+            assert.deepEqual(result, {start: discountStart, end: discountEnd});
+        });
+
+        it('discount_start takes precedence over legacy offer data', function () {
+            const discountStart = new Date('2025-05-01T00:00:00.000Z');
+            const subscription = createSubscription({
+                discount_start: discountStart,
+                discount_end: null
+            });
+
+            const result = getDiscountWindow(subscription, {duration: 'once'});
+
+            assert.deepEqual(result, {start: discountStart, end: null});
+        });
+    });
+
+    // Legacy fallback (no discount_start, uses offer duration)
+
+    describe('legacy fallback', function () {
+        it('returns null when no offer is provided', function () {
+            const subscription = createSubscription();
+
+            const result = getDiscountWindow(subscription, null);
+
+            assert.equal(result, null);
+        });
+
+        it('returns null for once duration', function () {
+            const subscription = createSubscription();
+
+            const result = getDiscountWindow(subscription, {duration: 'once'});
+
+            assert.equal(result, null);
+        });
+
+        it('returns window with null end for forever duration', function () {
+            const startDate = new Date('2025-01-01T00:00:00.000Z');
+            const subscription = createSubscription({start_date: startDate});
+
+            const result = getDiscountWindow(subscription, {duration: 'forever'});
+
+            assert.deepEqual(result, {start: startDate, end: null});
+        });
+
+        it('returns window for repeating offer still within duration', function () {
+            const startDate = new Date(Date.now() - 90 * 24 * 60 * 60 * 1000); // 3 months ago
+            const subscription = createSubscription({start_date: startDate});
+
+            const result = getDiscountWindow(subscription, {duration: 'repeating', duration_in_months: 6});
+
+            assert.notEqual(result, null);
+            assert.deepEqual(result.start, startDate);
+            assert.ok(result.end instanceof Date);
+            assert.ok(result.end > new Date());
+        });
+
+        it('returns null for repeating offer past its duration', function () {
+            const startDate = new Date(Date.now() - 365 * 24 * 60 * 60 * 1000); // 1 year ago
+            const subscription = createSubscription({start_date: startDate});
+
+            const result = getDiscountWindow(subscription, {duration: 'repeating', duration_in_months: 6});
+
+            assert.equal(result, null);
+        });
+
+        it('returns null for repeating offer with zero duration_in_months', function () {
+            const subscription = createSubscription();
+
+            const result = getDiscountWindow(subscription, {duration: 'repeating', duration_in_months: 0});
+
+            assert.equal(result, null);
+        });
+
+        it('returns null for unknown duration', function () {
+            const subscription = createSubscription();
+
+            const result = getDiscountWindow(subscription, {duration: 'unknown'});
+
+            assert.equal(result, null);
+        });
+    });
+});

ghost/core/test/unit/server/services/members/members-api/utils/has-active-offer.test.js

@@ -97,7 +97,7 @@ describe('hasActiveOffer', function () {
     });
 
     it('returns true for a forever offer (legacy data)', async function () {
-        const model = createSubscriptionModel({offerId: 'offer_123'});
+        const model = createSubscriptionModel({offerId: 'offer_123', startDate: new Date('2025-01-01')});
         const offersAPI = createOffersAPI({duration: 'forever'});
         const result = await hasActiveOffer(model, offersAPI);