ghost 6.55.0 → 6.57.0

package/core/server/services/gifts/gift-checkout-offer.ts

@@ -0,0 +1,127 @@
+import errors from '@tryghost/errors';
+import type {GiftCadence} from './gift-schema';
+
+export type {GiftCadence} from './gift-schema';
+
+export interface GiftCheckoutTier {
+    status: string;
+    visibility: string;
+    type: string;
+    currency: string | null;
+    monthlyPrice: number | null;
+    yearlyPrice: number | null;
+}
+
+interface GiftDurationDefinition {
+    cadence: GiftCadence;
+    billingDuration: number;
+    portalPlan: 'monthly' | 'yearly';
+    priceProperty: 'monthlyPrice' | 'yearlyPrice';
+    multiplier: number;
+}
+
+export interface ResolvedGiftDuration extends GiftDurationDefinition {
+    totalMonths: number;
+    isCadenceOnly: boolean;
+}
+
+export interface GiftCheckoutPlan {
+    cadence: GiftCadence;
+    duration: number;
+    totalMonths: number;
+    amount: number;
+}
+
+// Mirrored by the Portal catalogue in apps/portal/src/utils/gift-subscriptions.ts
+// until later customization work makes durations server-provided
+const GIFT_DURATION_CATALOGUE = new Map<number, GiftDurationDefinition>([
+    [1, {cadence: 'month', billingDuration: 1, portalPlan: 'monthly', priceProperty: 'monthlyPrice', multiplier: 1}],
+    [3, {cadence: 'month', billingDuration: 3, portalPlan: 'monthly', priceProperty: 'monthlyPrice', multiplier: 3}],
+    [6, {cadence: 'month', billingDuration: 6, portalPlan: 'monthly', priceProperty: 'monthlyPrice', multiplier: 6}],
+    [12, {cadence: 'year', billingDuration: 1, portalPlan: 'yearly', priceProperty: 'yearlyPrice', multiplier: 1}]
+]);
+
+function invalidGiftOffer(context: string) {
+    return new errors.BadRequestError({
+        message: 'Bad Request.',
+        context
+    });
+}
+
+export function resolveGiftDuration({
+    duration,
+    cadence
+}: {
+    duration?: number;
+    cadence?: string;
+}): ResolvedGiftDuration {
+    let totalMonths = duration;
+
+    if (totalMonths === undefined) {
+        if (cadence === 'month') {
+            totalMonths = 1;
+        } else if (cadence === 'year') {
+            totalMonths = 12;
+        } else {
+            throw invalidGiftOffer('Expected a supported gift duration or legacy cadence');
+        }
+    }
+
+    if (typeof totalMonths !== 'number' || !Number.isInteger(totalMonths)) {
+        throw invalidGiftOffer(`Unsupported gift duration "${totalMonths}"`);
+    }
+
+    const offer = GIFT_DURATION_CATALOGUE.get(totalMonths);
+
+    if (!offer) {
+        throw invalidGiftOffer(`Unsupported gift duration "${totalMonths}"`);
+    }
+
+    if (cadence !== undefined && cadence !== offer.cadence) {
+        throw invalidGiftOffer(`Gift duration "${totalMonths}" conflicts with cadence "${cadence}"`);
+    }
+
+    return {
+        ...offer,
+        totalMonths,
+        isCadenceOnly: duration === undefined
+    };
+}
+
+export function validateGiftCheckoutOffer({
+    tier,
+    portalPlans,
+    offer
+}: {
+    tier: GiftCheckoutTier;
+    portalPlans: unknown;
+    offer: ResolvedGiftDuration;
+}): GiftCheckoutPlan {
+    if (tier.status !== 'active' || tier.visibility !== 'public' || tier.type !== 'paid') {
+        throw invalidGiftOffer('The requested tier is not available for gift purchases');
+    }
+
+    // legacy cadence-only requests predate the Portal plan gate, keep them working
+    if (!offer.isCadenceOnly && (!Array.isArray(portalPlans) || !portalPlans.includes(offer.portalPlan))) {
+        throw invalidGiftOffer(`The ${offer.portalPlan} Portal plan is not available`);
+    }
+
+    const unitAmount = tier[offer.priceProperty];
+
+    if (typeof unitAmount !== 'number' || !Number.isSafeInteger(unitAmount) || unitAmount <= 0 || typeof tier.currency !== 'string' || !tier.currency) {
+        throw invalidGiftOffer('The requested tier does not have a valid gift price');
+    }
+
+    const amount = unitAmount * offer.multiplier;
+
+    if (!Number.isSafeInteger(amount)) {
+        throw invalidGiftOffer('The requested gift amount is invalid');
+    }
+
+    return {
+        cadence: offer.cadence,
+        duration: offer.billingDuration,
+        totalMonths: offer.totalMonths,
+        amount
+    };
+}

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.giftCodec = void 0;
+exports.decodeGiftRow = decodeGiftRow;
+exports.encodeGift = encodeGift;
+const zod_1 = require("zod");
+const gift_1 = require("./gift");
+const gift_schema_1 = require("./gift-schema");
+exports.giftCodec = zod_1.z.codec(gift_schema_1.DbGift, zod_1.z.instanceof(gift_1.Gift), {
+    decode: row => new gift_1.Gift({
+        token: row.token,
+        buyerEmail: row.buyer_email,
+        buyerMemberId: row.buyer_member_id,
+        redeemerMemberId: row.redeemer_member_id,
+        tierId: row.tier_id,
+        cadence: row.cadence,
+        duration: row.duration,
+        currency: row.currency,
+        amount: row.amount,
+        stripeCheckoutSessionId: row.stripe_checkout_session_id,
+        stripePaymentIntentId: row.stripe_payment_intent_id,
+        consumesAt: row.consumes_at,
+        expiresAt: row.expires_at,
+        status: row.status,
+        purchasedAt: row.purchased_at,
+        redeemedAt: row.redeemed_at,
+        consumedAt: row.consumed_at,
+        expiredAt: row.expired_at,
+        refundedAt: row.refunded_at,
+        consumesSoonReminderSentAt: row.consumes_soon_reminder_sent_at
+    }),
+    encode: gift => ({
+        token: gift.token,
+        buyer_email: gift.buyerEmail,
+        buyer_member_id: gift.buyerMemberId,
+        redeemer_member_id: gift.redeemerMemberId,
+        tier_id: gift.tierId,
+        cadence: gift.cadence,
+        duration: gift.duration,
+        currency: gift.currency,
+        amount: gift.amount,
+        stripe_checkout_session_id: gift.stripeCheckoutSessionId,
+        stripe_payment_intent_id: gift.stripePaymentIntentId,
+        consumes_at: gift.consumesAt,
+        expires_at: gift.expiresAt,
+        status: gift.status,
+        purchased_at: gift.purchasedAt,
+        redeemed_at: gift.redeemedAt,
+        consumed_at: gift.consumedAt,
+        expired_at: gift.expiredAt,
+        refunded_at: gift.refundedAt,
+        consumes_soon_reminder_sent_at: gift.consumesSoonReminderSentAt
+    })
+});
+function decodeGiftRow(input) {
+    return exports.giftCodec.parse(input);
+}
+function encodeGift(gift) {
+    const row = zod_1.z.encode(exports.giftCodec, gift);
+    // DbDate encodes to Date at runtime, but z.encode types the row as DbGift input,
+    // whose date fields also accept strings and numbers. Parse to narrow it to GiftRow.
+    return gift_schema_1.DbGift.parse(row);
+}

package/core/server/services/gifts/gift-codec.ts

@@ -0,0 +1,62 @@
+import {z} from 'zod';
+import {Gift} from './gift';
+import {DbGift} from './gift-schema';
+
+export const giftCodec = z.codec(DbGift, z.instanceof(Gift), {
+    decode: row => new Gift({
+        token: row.token,
+        buyerEmail: row.buyer_email,
+        buyerMemberId: row.buyer_member_id,
+        redeemerMemberId: row.redeemer_member_id,
+        tierId: row.tier_id,
+        cadence: row.cadence,
+        duration: row.duration,
+        currency: row.currency,
+        amount: row.amount,
+        stripeCheckoutSessionId: row.stripe_checkout_session_id,
+        stripePaymentIntentId: row.stripe_payment_intent_id,
+        consumesAt: row.consumes_at,
+        expiresAt: row.expires_at,
+        status: row.status,
+        purchasedAt: row.purchased_at,
+        redeemedAt: row.redeemed_at,
+        consumedAt: row.consumed_at,
+        expiredAt: row.expired_at,
+        refundedAt: row.refunded_at,
+        consumesSoonReminderSentAt: row.consumes_soon_reminder_sent_at
+    }),
+    encode: gift => ({
+        token: gift.token,
+        buyer_email: gift.buyerEmail,
+        buyer_member_id: gift.buyerMemberId,
+        redeemer_member_id: gift.redeemerMemberId,
+        tier_id: gift.tierId,
+        cadence: gift.cadence,
+        duration: gift.duration,
+        currency: gift.currency,
+        amount: gift.amount,
+        stripe_checkout_session_id: gift.stripeCheckoutSessionId,
+        stripe_payment_intent_id: gift.stripePaymentIntentId,
+        consumes_at: gift.consumesAt,
+        expires_at: gift.expiresAt,
+        status: gift.status,
+        purchased_at: gift.purchasedAt,
+        redeemed_at: gift.redeemedAt,
+        consumed_at: gift.consumedAt,
+        expired_at: gift.expiredAt,
+        refunded_at: gift.refundedAt,
+        consumes_soon_reminder_sent_at: gift.consumesSoonReminderSentAt
+    })
+});
+
+export function decodeGiftRow(input: unknown): Gift {
+    return giftCodec.parse(input);
+}
+
+export function encodeGift(gift: Gift): z.output<typeof DbGift> {
+    const row = z.encode(giftCodec, gift);
+
+    // DbDate encodes to Date at runtime, but z.encode types the row as DbGift input,
+    // whose date fields also accept strings and numbers. Parse to narrow it to GiftRow.
+    return DbGift.parse(row);
+}

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

@@ -7,16 +7,13 @@ exports.GiftController = void 0;
 const errors_1 = __importDefault(require("@tryghost/errors"));
 class GiftController {
     service;
-    tiersService;
-    constructor({ service, tiersService }) {
+    constructor({ service }) {
         this.service = service;
-        this.tiersService = tiersService;
     }
     async getRedeemable(frame) {
         const token = frame.data.token;
         const memberStatus = frame.options?.context?.member?.status ?? null;
-        const gift = await this.service.getRedeemable(token, memberStatus);
-        return this.serializeGift(gift);
+        return this.service.getRedeemable({ token, memberStatus });
     }
     async redeem(frame) {
         const token = frame.data.token;
@@ -26,32 +23,10 @@ class GiftController {
                 message: 'Member authentication required.'
             });
         }
-        const gift = await this.service.redeem(token, member.id);
-        return this.serializeGift(gift);
-    }
-    async serializeGift(gift) {
-        const tier = await this.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
-            }
-        };
+        return this.service.redeem({
+            token,
+            memberId: member.id
+        });
     }
 }
 exports.GiftController = GiftController;

package/core/server/services/gifts/gift-controller.ts

@@ -1,5 +1,4 @@
 import errors from '@tryghost/errors';
-import {Gift, type GiftCadence} from './gift';
 import {GiftService} from './gift-service';
 
 type Frame = {
@@ -16,57 +15,22 @@ type Frame = {
     };
 };
 
-type SerializedTier = {
-    id: string;
-    name: string;
-    description: string | null;
-    benefits: string[];
-};
-
-type Tier = {
-    name: string;
-    toJSON(): SerializedTier;
-};
-
-type GiftDTO = {
-    token: string;
-    cadence: GiftCadence;
-    duration: number;
-    currency: string;
-    amount: number;
-    expires_at: Date;
-    consumes_at: Date | null;
-    tier: SerializedTier;
-};
-
-type TiersService = {
-    api: {
-        read(idString: string): Promise<Tier | null>;
-    };
-};
-
 export class GiftController {
     private readonly service: GiftService;
-    private readonly tiersService: TiersService;
 
     constructor({
-        service,
-        tiersService
+        service
     }: {
         service: GiftService;
-        tiersService: TiersService;
     }) {
         this.service = service;
-        this.tiersService = tiersService;
     }
 
     async getRedeemable(frame: Frame) {
         const token = frame.data.token;
         const memberStatus = frame.options?.context?.member?.status ?? null;
 
-        const gift = await this.service.getRedeemable(token, memberStatus);
-
-        return this.serializeGift(gift);
+        return this.service.getRedeemable({token, memberStatus});
     }
 
     async redeem(frame: Frame) {
@@ -79,36 +43,9 @@ export class GiftController {
             });
         }
 
-        const gift = await this.service.redeem(token, member.id);
-
-        return this.serializeGift(gift);
-    }
-
-    private async serializeGift(gift: Gift): Promise<GiftDTO> {
-        const tier = await this.tiersService.api.read(gift.tierId);
-
-        if (!tier) {
-            throw new errors.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
-            }
-        };
+        return this.service.redeem({
+            token,
+            memberId: member.id
+        });
     }
 }

package/core/server/services/gifts/gift-email-service.ts

@@ -1,4 +1,5 @@
 import {GiftEmailRenderer, Translate} from './gift-email-renderer';
+import type {GiftCadence} from './gift-schema';
 
 const DEFAULT_DATE_LOCALE = 'en-gb';
 
@@ -29,7 +30,7 @@ interface PurchaseConfirmationData {
     buyerEmail: string;
     token: string;
     tierName: string;
-    cadence: 'month' | 'year';
+    cadence: GiftCadence;
     duration: number;
     expiresAt: Date;
 }
@@ -69,7 +70,7 @@ export class GiftEmailService {
         }
     }
 
-    private getCadenceLabel(cadence: 'month' | 'year', duration: number): string {
+    private getCadenceLabel(cadence: GiftCadence, duration: number): string {
         if (duration === 1) {
             return cadence === 'year' ? this.t('one-year') : this.t('one-month');
         }

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbGift = exports.GiftStatusSchema = exports.GiftCadenceSchema = void 0;
+const zod_1 = require("zod");
+const db_date_1 = require("../../lib/db-date");
+exports.GiftCadenceSchema = zod_1.z.enum(['month', 'year']);
+exports.GiftStatusSchema = zod_1.z.enum(['purchased', 'redeemed', 'consumed', 'expired', 'refunded']);
+/**
+ * The persisted gift row. Bookshelf remains the persistence implementation, but
+ * values read through it are still runtime data and are validated before they
+ * become trusted gift-domain values.
+ */
+exports.DbGift = zod_1.z.object({
+    token: zod_1.z.string(),
+    buyer_email: zod_1.z.string(),
+    buyer_member_id: zod_1.z.string().nullable(),
+    redeemer_member_id: zod_1.z.string().nullable(),
+    tier_id: zod_1.z.string(),
+    cadence: exports.GiftCadenceSchema,
+    duration: zod_1.z.number().int().nonnegative(),
+    currency: zod_1.z.string(),
+    amount: zod_1.z.number().int().nonnegative(),
+    stripe_checkout_session_id: zod_1.z.string(),
+    stripe_payment_intent_id: zod_1.z.string(),
+    consumes_at: db_date_1.DbDate.nullable(),
+    expires_at: db_date_1.DbDate,
+    status: exports.GiftStatusSchema,
+    purchased_at: db_date_1.DbDate,
+    redeemed_at: db_date_1.DbDate.nullable(),
+    consumed_at: db_date_1.DbDate.nullable(),
+    expired_at: db_date_1.DbDate.nullable(),
+    refunded_at: db_date_1.DbDate.nullable(),
+    consumes_soon_reminder_sent_at: db_date_1.DbDate.nullable().default(null)
+});

package/core/server/services/gifts/gift-schema.ts

@@ -0,0 +1,39 @@
+import {z} from 'zod';
+import {DbDate} from '../../lib/db-date';
+import type {CamelKeys} from '../../lib/case-keys';
+
+export const GiftCadenceSchema = z.enum(['month', 'year']);
+export const GiftStatusSchema = z.enum(['purchased', 'redeemed', 'consumed', 'expired', 'refunded']);
+export type GiftCadence = z.infer<typeof GiftCadenceSchema>;
+export type GiftStatus = z.infer<typeof GiftStatusSchema>;
+
+/**
+ * The persisted gift row. Bookshelf remains the persistence implementation, but
+ * values read through it are still runtime data and are validated before they
+ * become trusted gift-domain values.
+ */
+export const DbGift = z.object({
+    token: z.string(),
+    buyer_email: z.string(),
+    buyer_member_id: z.string().nullable(),
+    redeemer_member_id: z.string().nullable(),
+    tier_id: z.string(),
+    cadence: GiftCadenceSchema,
+    duration: z.number().int().nonnegative(),
+    currency: z.string(),
+    amount: z.number().int().nonnegative(),
+    stripe_checkout_session_id: z.string(),
+    stripe_payment_intent_id: z.string(),
+    consumes_at: DbDate.nullable(),
+    expires_at: DbDate,
+    status: GiftStatusSchema,
+    purchased_at: DbDate,
+    redeemed_at: DbDate.nullable(),
+    consumed_at: DbDate.nullable(),
+    expired_at: DbDate.nullable(),
+    refunded_at: DbDate.nullable(),
+    consumes_soon_reminder_sent_at: DbDate.nullable().default(null)
+});
+
+export type GiftRow = z.output<typeof DbGift>;
+export type GiftData = CamelKeys<GiftRow>;

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');
             }