ghost 6.55.0 → 6.56.0

package/core/server/services/gifts/gift-service-wrapper.js

@@ -23,12 +23,13 @@ class GiftServiceWrapper {
             return;
         }
 
-        const {Gift: GiftModel} = require('../../models');
+        const {Gift: GiftModel, MemberStripeCustomer: StripeCustomerModel} = require('../../models');
         const {GiftBookshelfRepository} = require('./gift-bookshelf-repository');
         const {GiftService} = require('./gift-service');
         const {GiftReminderScheduler} = require('./gift-reminder-scheduler');
         const {GiftEmailService} = require('./gift-email-service');
         const {GiftController} = require('./gift-controller');
+        const GiftCheckoutAdapter = require('./gift-checkout-adapter');
         const membersService = require('../members');
         const tiersService = require('../tiers');
         const staffService = require('../staff');
@@ -41,6 +42,7 @@ class GiftServiceWrapper {
 
         const {GhostMailer} = require('../mail');
         const settingsCache = require('../../../shared/settings-cache');
+        const labsService = require('../../../shared/labs');
         const urlUtils = require('../../../shared/url-utils').default;
         const settingsHelpers = require('../settings-helpers');
         const EmailAddressParser = require('../email-address/email-address-parser');
@@ -50,6 +52,10 @@ class GiftServiceWrapper {
         const repository = new GiftBookshelfRepository({
             GiftModel
         });
+        const checkoutAdapter = new GiftCheckoutAdapter({
+            StripeCustomerModel,
+            getStripeApi: () => require('../stripe').api
+        });
 
         const giftEmailService = new GiftEmailService({
             mailer: new GhostMailer(),
@@ -77,23 +83,19 @@ class GiftServiceWrapper {
             get staffServiceEmails() {
                 return staffService.api.emails;
             },
-            giftReminderScheduler
+            giftReminderScheduler,
+            checkoutAdapter,
+            labsService,
+            settingsCache
         });
 
         this.controller = new GiftController({
-            service: this.service,
-            tiersService
+            service: this.service
         });
 
         DomainEvents.subscribe(SubscriptionActivatedEvent, async (event) => {
             try {
-                const gift = await this.service.getActiveByMember(event.data.memberId);
-
-                if (!gift) {
-                    return;
-                }
-
-                await this.service.consume(gift.token);
+                await this.service.handlePaidSubscriptionActivation(event.data.memberId);
             } catch (err) {
                 logging.error(err, 'Failed to consume gift on paid subscription activation');
             }

package/core/server/services/gifts/gift-service.js

@@ -7,9 +7,12 @@ exports.GiftService = void 0;
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const errors_1 = __importDefault(require("@tryghost/errors"));
 const logging_1 = __importDefault(require("@tryghost/logging"));
+const zod_1 = require("zod");
 const gift_1 = require("./gift");
+const gift_schema_1 = require("./gift-schema");
 const tpl_1 = __importDefault(require("@tryghost/tpl"));
 const constants_1 = require("./constants");
+const gift_checkout_offer_1 = require("./gift-checkout-offer");
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
 const GIFT_REMINDER_LEAD_MS = constants_1.GIFT_REMINDER_LEAD_DAYS * MS_PER_DAY;
 const GIFT_REMINDER_FLOOR_MS = constants_1.GIFT_REMINDER_FLOOR_DAYS * MS_PER_DAY;
@@ -26,11 +29,119 @@ const errorMessages = {
     giftMissingConsumesAt: 'This gift is missing a "consumes at" date.',
     giftMemberAlreadyHasGift: 'Member already has a different active gift attached.'
 };
+const GiftPurchaseDataSchema = zod_1.z.object({
+    token: zod_1.z.string().min(1),
+    buyerEmail: zod_1.z.string().min(1),
+    stripeCustomerId: zod_1.z.string().min(1).nullable(),
+    tierId: zod_1.z.string().min(1),
+    cadence: gift_schema_1.GiftCadenceSchema,
+    duration: zod_1.z.number().int().positive(),
+    currency: zod_1.z.string().min(1),
+    amount: zod_1.z.number().int().nonnegative(),
+    stripeCheckoutSessionId: zod_1.z.string().min(1),
+    stripePaymentIntentId: zod_1.z.string().min(1)
+});
 class GiftService {
     deps;
     constructor(deps) {
         this.deps = deps;
     }
+    async startCheckout(input) {
+        if (input.offerId) {
+            throw new errors_1.default.BadRequestError({
+                message: 'Bad Request.',
+                context: 'Offers cannot be applied to gift subscriptions'
+            });
+        }
+        if (!input.tierId) {
+            throw new errors_1.default.BadRequestError({
+                message: 'Bad Request.',
+                context: 'Expected offerId or tierId, received none'
+            });
+        }
+        let resolvedDuration = null;
+        let cadence;
+        if (this.deps.labsService.isSet('giftSubCustomization')) {
+            resolvedDuration = (0, gift_checkout_offer_1.resolveGiftDuration)(input);
+            cadence = resolvedDuration.cadence;
+        }
+        else {
+            if (input.cadence !== 'month' && input.cadence !== 'year') {
+                const receivedCadence = input.cadence ? `"${input.cadence}"` : input.cadence;
+                throw new errors_1.default.BadRequestError({
+                    message: 'Bad Request.',
+                    context: `Expected cadence to be "month" or "year", received ${receivedCadence}`
+                });
+            }
+            cadence = input.cadence;
+        }
+        let tier;
+        try {
+            tier = await this.deps.tiersService.api.read(input.tierId);
+        }
+        catch (err) {
+            logging_1.default.error(err);
+            tier = null;
+        }
+        if (!tier) {
+            throw new errors_1.default.BadRequestError({
+                message: 'This tier does not exist.',
+                context: `Tier with id "${input.tierId}" not found`
+            });
+        }
+        if (tier.status === 'archived') {
+            throw new errors_1.default.NoPermissionError({
+                message: 'This tier is archived.'
+            });
+        }
+        let duration = 1;
+        let totalMonths;
+        let amount = tier.getPrice(cadence);
+        if (resolvedDuration) {
+            const plan = (0, gift_checkout_offer_1.validateGiftCheckoutOffer)({
+                tier,
+                portalPlans: this.deps.settingsCache.get('portal_plans'),
+                offer: resolvedDuration
+            });
+            cadence = plan.cadence;
+            duration = plan.duration;
+            totalMonths = plan.totalMonths;
+            amount = plan.amount;
+        }
+        const tierId = typeof tier.id === 'string' ? tier.id : tier.id.toHexString();
+        const token = this.generateToken();
+        const successUrl = new URL(input.successUrl);
+        successUrl.searchParams.set('stripe', 'gift-purchase-success');
+        successUrl.searchParams.set('gift_token', token);
+        successUrl.searchParams.set('gift_tier', tierId);
+        successUrl.searchParams.set('gift_cadence', cadence);
+        if (totalMonths !== undefined) {
+            successUrl.searchParams.set('gift_duration', String(totalMonths));
+        }
+        const customerId = input.buyer.isAuthenticated
+            ? await this.deps.checkoutAdapter.getCustomerId(input.buyer)
+            : null;
+        const url = await this.deps.checkoutAdapter.createSession({
+            amount,
+            currency: tier.currency.toLowerCase(),
+            tierName: tier.name,
+            cadence,
+            duration,
+            metadata: {
+                ...input.metadata,
+                ghost_gift: 'true',
+                gift_token: token,
+                tier_id: tierId,
+                cadence,
+                duration: String(duration)
+            },
+            successUrl: successUrl.toString(),
+            cancelUrl: input.cancelUrl,
+            customerId,
+            customerEmail: customerId ? null : input.buyer.email
+        });
+        return { url };
+    }
     generateToken() {
         /**
          * Combinations: 62^12 ≈ 3.23 × 10^21 (~3.23 sextillion)
@@ -43,11 +154,17 @@ class GiftService {
         }
         return token;
     }
-    async recordPurchase(data) {
-        const duration = Number.parseInt(data.duration);
-        if (Number.isNaN(duration)) {
-            throw new errors_1.default.ValidationError({ message: `Invalid gift duration: ${data.duration}` });
+    async completePurchase(input) {
+        const parsed = GiftPurchaseDataSchema.safeParse(input);
+        if (!parsed.success) {
+            const issue = parsed.error.issues[0];
+            throw new errors_1.default.ValidationError({
+                message: 'Invalid gift purchase data.',
+                property: issue.path.join('.'),
+                context: issue.message
+            });
         }
+        const data = parsed.data;
         if (await this.deps.giftRepository.existsByCheckoutSessionId(data.stripeCheckoutSessionId)) {
             return false;
         }
@@ -60,7 +177,7 @@ class GiftService {
             buyerMemberId: member?.id ?? null,
             tierId: data.tierId,
             cadence: data.cadence,
-            duration,
+            duration: data.duration,
             currency: data.currency,
             amount: data.amount,
             stripeCheckoutSessionId: data.stripeCheckoutSessionId,
@@ -80,7 +197,7 @@ class GiftService {
                 currency: data.currency,
                 tierName: tier.name,
                 cadence: data.cadence,
-                duration
+                duration: data.duration
             });
         }
         catch (err) {
@@ -92,7 +209,7 @@ class GiftService {
                 token: data.token,
                 tierName: tier.name,
                 cadence: data.cadence,
-                duration,
+                duration: data.duration,
                 expiresAt: gift.expiresAt
             });
         }
@@ -101,10 +218,7 @@ class GiftService {
         }
         return true;
     }
-    async getByToken(token) {
-        return this.deps.giftRepository.getByToken(token);
-    }
-    async assertRedeemable(gift, memberStatus) {
+    assertRedeemable(gift, memberStatus) {
         const redeemableCheck = gift.checkRedeemable(memberStatus);
         if (!redeemableCheck.redeemable) {
             switch (redeemableCheck.reason) {
@@ -143,45 +257,25 @@ class GiftService {
         }
         return gift;
     }
-    async getRedeemable(token, memberStatus) {
-        const gift = await this.deps.giftRepository.getByToken(token);
+    async getRedeemable(input) {
+        const gift = await this.deps.giftRepository.getByToken(input.token);
         if (!gift) {
             throw new errors_1.default.NotFoundError({ message: (0, tpl_1.default)(errorMessages.giftNotFound) });
         }
-        await this.assertRedeemable(gift, memberStatus);
-        return gift;
+        this.assertRedeemable(gift, input.memberStatus);
+        return this.serializeRedemption(gift);
     }
-    async redeem(token, memberId, options = {}) {
+    async redeem(input) {
         const run = async (transacting) => {
-            const member = await this.deps.memberRepository.get({ id: memberId }, { transacting, forUpdate: true });
-            if (!member) {
-                throw new errors_1.default.NotFoundError({ message: `Member not found: ${memberId}` });
-            }
-            const gift = await this.deps.giftRepository.getByToken(token, { transacting, forUpdate: true });
-            if (!gift) {
-                throw new errors_1.default.NotFoundError({ message: (0, tpl_1.default)(errorMessages.giftNotFound) });
-            }
-            if (options.newMember) {
-                await this.assertRedeemable(gift, null);
-            }
-            else {
-                await this.assertRedeemable(gift, member.get('status'));
-            }
-            const redeemed = gift.redeem({ memberId });
-            await this.deps.memberRepository.update({
-                products: [{
-                        id: redeemed.tierId,
-                        expiry_at: redeemed.consumesAt
-                    }],
-                status: 'gift'
-            }, { id: memberId, transacting });
-            await this.deps.giftRepository.update(redeemed, { transacting });
-            // Gift members receive the paid welcome email, as they receive access to paid content
-            await this.deps.memberRepository.triggerMemberSignupAutomation(memberId, member.get('email'), 'paid', { transacting });
-            return { redeemed, member };
+            const { redeemed, member } = await this.redeemGift(input.token, input.memberId, {
+                transacting,
+                newMember: input.newMember
+            });
+            const redemption = await this.serializeRedemption(redeemed);
+            return { redeemed, member, redemption };
         };
-        const { redeemed, member } = options.transacting
-            ? await run(options.transacting)
+        const { redeemed, member, redemption } = input.transacting
+            ? await run(input.transacting)
             : await this.deps.giftRepository.transaction(run);
         const notify = async () => {
             try {
@@ -204,14 +298,43 @@ class GiftService {
             }
             await this.deps.giftReminderScheduler.scheduleFor(redeemed);
         };
-        if (options.transacting) {
+        if (input.transacting) {
             // Only notify once the transaction has finished
-            options.transacting.executionPromise.then(notify, () => { });
+            input.transacting.executionPromise.then(notify, () => { });
         }
         else {
             await notify();
         }
-        return redeemed;
+        return redemption;
+    }
+    async redeemGift(token, memberId, options) {
+        const { transacting } = options;
+        const member = await this.deps.memberRepository.get({ id: memberId }, { transacting, forUpdate: true });
+        if (!member) {
+            throw new errors_1.default.NotFoundError({ message: `Member not found: ${memberId}` });
+        }
+        const gift = await this.deps.giftRepository.getByToken(token, { transacting, forUpdate: true });
+        if (!gift) {
+            throw new errors_1.default.NotFoundError({ message: (0, tpl_1.default)(errorMessages.giftNotFound) });
+        }
+        if (options.newMember) {
+            this.assertRedeemable(gift, null);
+        }
+        else {
+            this.assertRedeemable(gift, member.get('status'));
+        }
+        const redeemed = gift.redeem({ memberId });
+        await this.deps.memberRepository.update({
+            products: [{
+                    id: redeemed.tierId,
+                    expiry_at: redeemed.consumesAt
+                }],
+            status: 'gift'
+        }, { id: memberId, transacting });
+        await this.deps.giftRepository.update(redeemed, { transacting });
+        // Gift members receive the paid welcome email, as they receive access to paid content
+        await this.deps.memberRepository.triggerMemberSignupAutomation(memberId, member.get('email'), 'paid', { transacting });
+        return { redeemed, member };
     }
     async getActiveByMember(memberId, options = {}) {
         if (!memberId) {
@@ -232,7 +355,66 @@ class GiftService {
         const diffDays = Math.ceil((gift.consumesAt.getTime() - now.getTime()) / MS_PER_DAY);
         return Math.max(0, diffDays);
     }
-    async reassignRedeemer(giftId, memberId, options = {}) {
+    async preparePaidContinuation({ memberId, memberStatus }) {
+        if (memberStatus !== 'gift') {
+            throw new errors_1.default.BadRequestError({
+                message: 'Bad Request.',
+                context: 'Member does not have an active gift subscription'
+            });
+        }
+        const gift = await this.getActiveByMember(memberId);
+        if (!gift) {
+            throw new errors_1.default.BadRequestError({
+                message: 'Bad Request.',
+                context: 'No active gift subscription found for member'
+            });
+        }
+        const remainingDays = this.getRemainingActiveDays(gift);
+        return {
+            tierId: gift.tierId,
+            cadence: gift.cadence,
+            trialDays: remainingDays > 0 ? Math.min(remainingDays, 730) : null
+        };
+    }
+    async getMemberPresentations(memberIds) {
+        const gifts = await this.getActiveByMembers(memberIds);
+        const presentations = new Map();
+        for (const [memberId, gift] of gifts) {
+            presentations.set(memberId, {
+                cadence: gift.cadence,
+                currency: gift.currency,
+                amount: gift.amount
+            });
+        }
+        return presentations;
+    }
+    async getPreview(token) {
+        const gift = await this.deps.giftRepository.getByToken(token);
+        if (!gift) {
+            return null;
+        }
+        const tier = await this.deps.tiersService.api.read(gift.tierId);
+        if (!tier) {
+            throw new errors_1.default.NotFoundError({ message: `Tier not found for gift: ${gift.token}` });
+        }
+        const tierJSON = tier.toJSON();
+        return {
+            cadence: gift.cadence,
+            duration: gift.duration,
+            tier: {
+                id: tierJSON.id,
+                name: tierJSON.name
+            }
+        };
+    }
+    browsePurchaseEvents(options, filter) {
+        return this.deps.giftRepository.browsePurchaseEvents(options, filter);
+    }
+    browseRedemptionEvents(options, filter) {
+        return this.deps.giftRepository.browseRedemptionEvents(options, filter);
+    }
+    async reassignRedeemer(input) {
+        const { giftId, memberId } = input;
         const run = async (transacting) => {
             const gift = await this.deps.giftRepository.getById(giftId, { transacting, forUpdate: true });
             if (!gift) {
@@ -284,11 +466,11 @@ class GiftService {
             await this.deps.giftRepository.update(reassignedGift, { transacting });
             return reassignedGift;
         };
-        return options.transacting
-            ? run(options.transacting)
-            : this.deps.giftRepository.transaction(run);
+        await (input.transacting
+            ? run(input.transacting)
+            : this.deps.giftRepository.transaction(run));
     }
-    async refund(paymentIntentId) {
+    async handlePaymentRefund({ paymentIntentId }) {
         const gift = await this.deps.giftRepository.getByPaymentIntentId(paymentIntentId);
         if (!gift) {
             return false;
@@ -311,6 +493,13 @@ class GiftService {
         });
         return true;
     }
+    async handlePaidSubscriptionActivation(memberId) {
+        const gift = await this.getActiveByMember(memberId);
+        if (!gift) {
+            return false;
+        }
+        return Boolean(await this.consume(gift.token));
+    }
     async consume(token, options = {}) {
         const run = async (transacting) => {
             // Fetch with a row lock to prevent race conditions under concurrency
@@ -465,5 +654,29 @@ class GiftService {
         });
         return true;
     }
+    async serializeRedemption(gift) {
+        const tier = await this.deps.tiersService.api.read(gift.tierId);
+        if (!tier) {
+            throw new errors_1.default.InternalServerError({
+                message: `Tier ${gift.tierId} not found for gift: ${gift.token}`
+            });
+        }
+        const tierJSON = tier.toJSON();
+        return {
+            token: gift.token,
+            cadence: gift.cadence,
+            duration: gift.duration,
+            currency: gift.currency,
+            amount: gift.amount,
+            expires_at: gift.expiresAt,
+            consumes_at: gift.consumesAt,
+            tier: {
+                id: tierJSON.id,
+                name: tierJSON.name,
+                description: tierJSON.description,
+                benefits: tierJSON.benefits
+            }
+        };
+    }
 }
 exports.GiftService = GiftService;