Added price details for gift subscriptions in Members API (#27647)

closes https://linear.app/ghost/issue/BER-3576

- attachSubscriptionsToMember was hardcoding amount: 0, currency: 'USD',
and interval: 'year' on the synthetic subscription returned for
gift-status members, even though the gift row already stores the real
cadence/currency/amount
- now hydrates the synthetic subscription with the values from the gift,
via a new bulk getActiveByMembers lookup on the gift repository to keep
browse() to a single query
- complimentary subscriptions keep the existing hardcoded shape;
gift-status members with no active redeemed gift fall back to the
defaults with a warning so the read/browse paths stay robust


API shape

For a gift member, `subscriptions[0].plan` and `subscriptions[0].price`
previously returned:
```json
{ "amount": 0, "currency": "USD", "interval": "year" }
```

After this PR they return the actual gift values, e.g.:
```
{ "amount": 5000, "currency": "usd", "interval": "year" }
```

Author: sagzy

ghost/core/core/server/services/gifts/gift-bookshelf-repository.ts

@@ -93,6 +93,29 @@ export class GiftBookshelfRepository implements GiftRepository {
         return model ? this.toGift(model) : null;
     }
 
+    async getActiveByMembers(memberIds: string[], options: RepositoryTransactionOptions = {}): Promise<Map<string, Gift>> {
+        const map = new Map<string, Gift>();
+
+        if (memberIds.length === 0) {
+            return map;
+        }
+
+        const idList = memberIds.map(id => `'${id}'`).join(',');
+        const collection = await this.model.findAll({
+            filter: `redeemer_member_id:[${idList}]+status:redeemed`,
+            ...options
+        });
+
+        for (const model of collection.models) {
+            const gift = this.toGift(model);
+            if (gift.redeemerMemberId) {
+                map.set(gift.redeemerMemberId, gift);
+            }
+        }
+
+        return map;
+    }
+
     async findPendingConsumption(): Promise<Gift[]> {
         const now = new Date();
 

ghost/core/core/server/services/gifts/gift-repository.ts

@@ -21,6 +21,7 @@ export interface GiftRepository {
     findPendingExpiration(): Promise<Gift[]>;
     findPendingReminder(options: FindPendingReminderOptions): Promise<Gift[]>;
     getActiveByMember(memberId: string, options?: RepositoryTransactionOptions): Promise<Gift | null>;
+    getActiveByMembers(memberIds: string[], options?: RepositoryTransactionOptions): Promise<Map<string, Gift>>;
     create(gift: Gift, options?: RepositoryTransactionOptions): Promise<void>;
     update(gift: Gift, options?: RepositoryTransactionOptions): Promise<void>;
     transaction<T>(callback: (transacting: unknown) => Promise<T>): Promise<T>;

ghost/core/core/server/services/gifts/gift-service.ts

@@ -373,6 +373,13 @@ export class GiftService {
         return this.deps.giftRepository.getActiveByMember(memberId, options);
     }
 
+    async getActiveByMembers(memberIds: string[], options: {transacting?: unknown} = {}): Promise<Map<string, Gift>> {
+        if (!memberIds || memberIds.length === 0) {
+            return new Map();
+        }
+        return this.deps.giftRepository.getActiveByMembers(memberIds, options);
+    }
+
     getRemainingActiveDays(gift: Gift, now: Date = new Date()): number {
         if (!gift.isRedeemed() || !gift.consumesAt || gift.isConsumed()) {
             return 0;

ghost/core/core/server/services/members/members-api/members-api.js

@@ -164,7 +164,8 @@ module.exports = function MembersAPI({
         emailSuppressionList,
         settingsHelpers,
         nextPaymentCalculator,
-        commentsService
+        commentsService,
+        giftService
     });
 
     const geolocationService = new GeolocationService();

ghost/core/core/server/services/members/members-api/services/member-bread-service.js

@@ -28,6 +28,11 @@ const messages = {
  * @typedef {import('@tryghost/members-offers/lib/application/OfferMapper').OfferDTO} OfferDTO
  */
 
+/**
+ * @typedef {object} IGiftServiceWrapper
+ * @prop {{getActiveByMembers: (memberIds: string[]) => Promise<Map<string, {cadence: 'month' | 'year', currency: string, amount: number}>>}} service
+ */
+
 module.exports = class MemberBREADService {
     /**
      * @param {object} deps
@@ -40,8 +45,9 @@ module.exports = class MemberBREADService {
      * @param {import('@tryghost/email-suppression-list/lib/email-suppression-list').IEmailSuppressionList} deps.emailSuppressionList
      * @param {import('@tryghost/settings-helpers')} deps.settingsHelpers
      * @param {import('./next-payment-calculator')} deps.nextPaymentCalculator
+     * @param {IGiftServiceWrapper} deps.giftService
      */
-    constructor({memberRepository, labsService, emailService, stripeService, offersAPI, memberAttributionService, emailSuppressionList, settingsHelpers, nextPaymentCalculator, commentsService}) {
+    constructor({memberRepository, labsService, emailService, stripeService, offersAPI, memberAttributionService, emailSuppressionList, settingsHelpers, nextPaymentCalculator, commentsService, giftService}) {
         this.offersAPI = offersAPI;
         /** @private */
         this.memberRepository = memberRepository;
@@ -61,13 +67,17 @@ module.exports = class MemberBREADService {
         this.nextPaymentCalculator = nextPaymentCalculator;
         /** @private */
         this.commentsService = commentsService;
+        /** @private */
+        this.giftService = giftService;
     }
 
     /**
      * @private
      * Adds missing complimentary subscriptions to a member and makes sure the tier of all subscriptions is set correctly.
+     * @param {Object} member JSON serialized member
+     * @param {Map<string, {cadence: 'month' | 'year', currency: string, amount: number}>} [giftMap] Map of memberId → active redeemed gift, used to populate real price details on synthetic gift subscriptions
      */
-    attachSubscriptionsToMember(member) {
+    attachSubscriptionsToMember(member, giftMap = new Map()) {
         if (!member.products || !Array.isArray(member.products)) {
             return member;
         }
@@ -87,6 +97,22 @@ module.exports = class MemberBREADService {
         // Note: a complimentary or gift subscription should always be the current member subscription and match its status,
         // as non-Stripe subscriptions are removed when a member continues with a Stripe paid subscription
         if (member.status === 'comped' || member.status === 'gift') {
+            let interval = 'year';
+            let currency = 'USD';
+            let amount = 0;
+            const nickname = member.status === 'gift' ? 'Gift subscription' : 'Complimentary';
+
+            if (member.status === 'gift') {
+                const gift = giftMap.get(member.id);
+                if (gift) {
+                    interval = gift.cadence;
+                    currency = gift.currency;
+                    amount = gift.amount;
+                } else {
+                    logging.warn(`No active gift found for gift member ${member.id} — falling back to default subscription price details.`);
+                }
+            }
+
             for (const product of member.products) {
                 if (!subscriptionProducts.includes(product.id)) {
                     const productAddEvent = member.productEvents.find(event => event.product_id === product.id && event.action === 'added');
@@ -97,8 +123,6 @@ module.exports = class MemberBREADService {
                         startDate = moment(productAddEvent.created_at);
                     }
 
-                    const nickname = member.status === 'gift' ? 'Gift subscription' : 'Complimentary';
-
                     member.subscriptions.push({
                         id: '',
                         tier: product,
@@ -110,9 +134,9 @@ module.exports = class MemberBREADService {
                         plan: {
                             id: '',
                             nickname,
-                            interval: 'year',
-                            currency: 'USD',
-                            amount: 0
+                            interval,
+                            currency,
+                            amount
                         },
                         status: 'active',
                         start_date: startDate,
@@ -124,10 +148,10 @@ module.exports = class MemberBREADService {
                             id: '',
                             price_id: '',
                             nickname,
-                            amount: 0,
-                            interval: 'year',
+                            amount,
+                            interval,
                             type: 'recurring',
-                            currency: 'USD',
+                            currency,
                             product: {
                                 id: '',
                                 product_id: product.id
@@ -283,6 +307,30 @@ module.exports = class MemberBREADService {
         }
     }
 
+    /**
+     * @private
+     * Fetches active redeemed gifts for any gift-status members in the input list.
+     * @param {import('bookshelf').Model[]} members - Bookshelf member models
+     * @returns {Promise<Map<string, {cadence: 'month' | 'year', currency: string, amount: number}>>} keyed by member.id → active Gift
+     */
+    async fetchActiveGiftsForMembers(members) {
+        const giftMemberIds = members
+            .filter(m => m.get('status') === 'gift')
+            .map(m => m.id);
+
+        if (giftMemberIds.length === 0) {
+            return new Map();
+        }
+
+        try {
+            return await this.giftService.service.getActiveByMembers(giftMemberIds);
+        } catch (e) {
+            logging.error(`Failed to load active gifts for members - ${giftMemberIds.join(', ')}.`);
+            logging.error(e);
+            return new Map();
+        }
+    }
+
     async read(data, options = {}) {
         const defaultWithRelated = [
             'labels',
@@ -324,12 +372,13 @@ module.exports = class MemberBREADService {
         const stripeSubscriptions = model.related('stripeSubscriptions');
 
         member.subscriptions = member.subscriptions.filter(sub => !!sub.price);
-        this.attachSubscriptionsToMember(member);
 
-        const [offerMap, offerRedemptionsMap] = await Promise.all([
+        const [offerMap, offerRedemptionsMap, giftMap] = await Promise.all([
             this.fetchSubscriptionOffers(stripeSubscriptions),
-            this.fetchSubscriptionOfferRedemptions(stripeSubscriptions)
+            this.fetchSubscriptionOfferRedemptions(stripeSubscriptions),
+            this.fetchActiveGiftsForMembers([model])
         ]);
+        this.attachSubscriptionsToMember(member, giftMap);
         this.attachOffersToSubscriptions(member, offerMap, offerRedemptionsMap);
         this.attachNextPaymentToSubscriptions(member);
         await this.attachAttributionsToMember(member, subscriptionIdMap);
@@ -578,17 +627,18 @@ module.exports = class MemberBREADService {
         }
 
         const subscriptions = page.data.flatMap(model => model.related('stripeSubscriptions').slice());
-        const [offerMap, offerRedemptionsMap] = await Promise.all([
+        const [offerMap, offerRedemptionsMap, giftMap] = await Promise.all([
             this.fetchSubscriptionOffers(subscriptions),
-            this.fetchSubscriptionOfferRedemptions(subscriptions)
+            this.fetchSubscriptionOfferRedemptions(subscriptions),
+            this.fetchActiveGiftsForMembers(page.data)
         ]);
 
         const bulkSuppressionData = await this.emailSuppressionList.getBulkSuppressionData(page.data.map(member => member.get('email')));
 
         const data = page.data.map((model, index) => {
             const member = model.toJSON(options);
             member.subscriptions = member.subscriptions.filter(sub => !!sub.price);
-            this.attachSubscriptionsToMember(member);
+            this.attachSubscriptionsToMember(member, giftMap);
             this.attachOffersToSubscriptions(member, offerMap, offerRedemptionsMap);
             this.attachNextPaymentToSubscriptions(member);
             if (!originalWithRelated.includes('products')) {

ghost/core/test/e2e-api/admin/members.test.js

@@ -14,6 +14,7 @@ const testUtils = require('../../utils');
 const Papa = require('papaparse');
 
 const models = require('../../../core/server/models');
+const {knex} = require('../../../core/server/data/db');
 const membersService = require('../../../core/server/services/members');
 const memberAttributionService = require('../../../core/server/services/member-attribution');
 const urlService = require('../../../core/server/services/url');
@@ -906,6 +907,85 @@ describe('Members API', function () {
             });
     });
 
+    it('Can read a member with an active gift subscription', async function () {
+        const member = await createGiftMember({email: 'gift-member-api-shape@test.com'});
+        const paidProduct = await getPaidProduct();
+        let gift;
+
+        try {
+            await models.Member.edit({
+                products: [{id: paidProduct.id}]
+            }, {id: member.id});
+
+            const giftAmount = 1500;
+            const giftCurrency = 'eur';
+            const giftCadence = 'month';
+
+            gift = await models.Gift.add({
+                token: `gift-admin-shape-${member.id}`,
+                buyer_email: 'gift-buyer@test.com',
+                buyer_member_id: null,
+                redeemer_member_id: member.id,
+                tier_id: paidProduct.id,
+                cadence: giftCadence,
+                duration: 1,
+                currency: giftCurrency,
+                amount: giftAmount,
+                stripe_checkout_session_id: `cs_admin_shape_${member.id}`,
+                stripe_payment_intent_id: `pi_admin_shape_${member.id}`,
+                consumes_at: new Date('2099-01-01T00:00:00.000Z'),
+                expires_at: new Date('2099-01-01T00:00:00.000Z'),
+                status: 'redeemed',
+                purchased_at: new Date(),
+                redeemed_at: new Date(),
+                consumed_at: null,
+                expired_at: null,
+                refunded_at: null
+            });
+
+            const {body: readBody} = await agent
+                .get(`/members/${member.id}/`)
+                .expectStatus(200);
+
+            assert.equal(readBody.members[0].status, 'gift');
+            assert.equal(readBody.members[0].subscriptions.length, 1, 'Gift member should expose a single synthetic subscription');
+
+            const readSub = readBody.members[0].subscriptions[0];
+            assert.equal(readSub.plan.nickname, 'Gift subscription');
+            assert.equal(readSub.price.nickname, 'Gift subscription');
+            assert.equal(readSub.plan.amount, giftAmount);
+            assert.equal(readSub.plan.currency, giftCurrency);
+            assert.equal(readSub.plan.interval, giftCadence);
+            assert.equal(readSub.price.amount, giftAmount);
+            assert.equal(readSub.price.currency, giftCurrency);
+            assert.equal(readSub.price.interval, giftCadence);
+
+            const {body: browseBody} = await agent
+                .get(`/members/?filter=${encodeURIComponent(`id:${member.id}`)}`)
+                .expectStatus(200);
+
+            const browsedMember = browseBody.members.find(m => m.id === member.id);
+            assert.ok(browsedMember, 'Gift member should appear in the browse response');
+
+            const browseSub = browsedMember.subscriptions[0];
+            assert.equal(browseSub.plan.nickname, 'Gift subscription');
+            assert.equal(browseSub.price.nickname, 'Gift subscription');
+            assert.equal(browseSub.plan.amount, giftAmount);
+            assert.equal(browseSub.plan.currency, giftCurrency);
+            assert.equal(browseSub.plan.interval, giftCadence);
+            assert.equal(browseSub.price.amount, giftAmount);
+            assert.equal(browseSub.price.currency, giftCurrency);
+            assert.equal(browseSub.price.interval, giftCadence);
+        } finally {
+            // Avoid leaking this fixture into later tests that count members.
+            // Gift.destroy is blocked by the model — fall back to a raw delete.
+            if (gift) {
+                await knex('gifts').where({id: gift.id}).del();
+            }
+            await models.Member.destroy({id: member.id});
+        }
+    });
+
     // Create a member
 
     it('Can add', async function () {