ghost 6.58.0 → 6.59.0

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

@@ -11,6 +11,9 @@ exports.giftCodec = zod_1.z.codec(gift_schema_1.DbGift, zod_1.z.instanceof(gift_
         token: row.token,
         buyerEmail: row.buyer_email,
         buyerMemberId: row.buyer_member_id,
+        buyerName: row.buyer_name,
+        recipientName: row.recipient_name,
+        personalMessage: row.personal_message,
         redeemerMemberId: row.redeemer_member_id,
         tierId: row.tier_id,
         cadence: row.cadence,
@@ -19,6 +22,7 @@ exports.giftCodec = zod_1.z.codec(gift_schema_1.DbGift, zod_1.z.instanceof(gift_
         amount: row.amount,
         stripeCheckoutSessionId: row.stripe_checkout_session_id,
         stripePaymentIntentId: row.stripe_payment_intent_id,
+        checkoutStartedAt: row.checkout_started_at,
         consumesAt: row.consumes_at,
         expiresAt: row.expires_at,
         status: row.status,
@@ -33,6 +37,9 @@ exports.giftCodec = zod_1.z.codec(gift_schema_1.DbGift, zod_1.z.instanceof(gift_
         token: gift.token,
         buyer_email: gift.buyerEmail,
         buyer_member_id: gift.buyerMemberId,
+        buyer_name: gift.buyerName,
+        recipient_name: gift.recipientName,
+        personal_message: gift.personalMessage,
         redeemer_member_id: gift.redeemerMemberId,
         tier_id: gift.tierId,
         cadence: gift.cadence,
@@ -41,6 +48,7 @@ exports.giftCodec = zod_1.z.codec(gift_schema_1.DbGift, zod_1.z.instanceof(gift_
         amount: gift.amount,
         stripe_checkout_session_id: gift.stripeCheckoutSessionId,
         stripe_payment_intent_id: gift.stripePaymentIntentId,
+        checkout_started_at: gift.checkoutStartedAt,
         consumes_at: gift.consumesAt,
         expires_at: gift.expiresAt,
         status: gift.status,

package/core/server/services/gifts/gift-delivery-bookshelf-repository.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GiftDeliveryBookshelfRepository = void 0;
+const db_date_1 = require("../../lib/db-date");
+const gift_delivery_codec_1 = require("./gift-delivery-codec");
+// Deliveries that still need a send attempt: never started, or claimed by a
+// process that has since died and left the claim stale
+function recoverableDeliveries(query, staleBefore) {
+    query.andWhere((recoverable) => {
+        recoverable.where('gift_deliveries.status', 'pending')
+            .orWhere((stale) => {
+            stale.where('gift_deliveries.status', 'sending')
+                .where('gift_deliveries.started_at', '<=', (0, db_date_1.toDatabaseDate)(staleBefore));
+        });
+    });
+}
+class GiftDeliveryBookshelfRepository {
+    model;
+    knex;
+    constructor({ GiftDeliveryModel, knex }) {
+        this.model = GiftDeliveryModel;
+        this.knex = knex;
+    }
+    async getById(id, options = {}) {
+        const model = await this.model.findOne({ id }, { require: false, ...options });
+        return model ? (0, gift_delivery_codec_1.decodeGiftDeliveryRow)(model.toJSON()) : null;
+    }
+    async getByGiftId(giftId, options = {}) {
+        const model = await this.model.findOne({ gift_id: giftId }, { require: false, ...options });
+        return model ? (0, gift_delivery_codec_1.decodeGiftDeliveryRow)(model.toJSON()) : null;
+    }
+    async findRecoverableForPurchasedGifts(staleBefore, limit) {
+        const rows = await this.knex('gift_deliveries')
+            .select('gift_deliveries.*')
+            .join('gifts', 'gifts.id', 'gift_deliveries.gift_id')
+            .where('gifts.status', 'purchased')
+            .modify(recoverableDeliveries, staleBefore)
+            .limit(limit);
+        return rows.map(gift_delivery_codec_1.decodeGiftDeliveryRow);
+    }
+    async tryStartDelivery(id, now, staleBefore) {
+        const claimed = await this.knex('gift_deliveries')
+            .where({ id })
+            .whereExists((query) => {
+            query.select('gifts.id')
+                .from('gifts')
+                .whereRaw('gifts.id = gift_deliveries.gift_id')
+                .where('gifts.status', 'purchased');
+        })
+            .modify(recoverableDeliveries, staleBefore)
+            .update({
+            status: 'sending',
+            started_at: (0, db_date_1.toDatabaseDate)(now)
+        });
+        if (claimed !== 1) {
+            return null;
+        }
+        return this.getById(id);
+    }
+    async markSent(id, sentAt, providerMessageId) {
+        return this.updateState(id, 'sending', {
+            status: 'sent',
+            email_sent_at: (0, db_date_1.toDatabaseDate)(sentAt),
+            email_provider_message_id: providerMessageId,
+            started_at: null
+        });
+    }
+    // A delivery cancelled while its email was in flight keeps the acceptance
+    // details so the message can still be correlated with transport outcomes
+    async recordCancelledAcceptance(id, sentAt, providerMessageId) {
+        return this.updateState(id, 'cancelled', {
+            email_sent_at: (0, db_date_1.toDatabaseDate)(sentAt),
+            email_provider_message_id: providerMessageId
+        });
+    }
+    async markFailed(id) {
+        return this.updateState(id, 'sending', {
+            status: 'failed',
+            started_at: null
+        });
+    }
+    async markCancelled(id) {
+        return this.updateState(id, 'sending', {
+            status: 'cancelled',
+            started_at: null
+        });
+    }
+    async cancelPendingForGift(token, options = {}) {
+        const db = options.transacting ?? this.knex;
+        const gift = db('gifts').select('id').where({ token });
+        const updated = await db('gift_deliveries')
+            .whereIn('status', ['pending', 'sending'])
+            .whereIn('gift_id', gift)
+            .update({ status: 'cancelled', started_at: null });
+        return updated === 1;
+    }
+    async create(delivery, options = {}) {
+        await this.model.add((0, gift_delivery_codec_1.encodeGiftDelivery)(delivery), options);
+    }
+    async updateState(id, from, data) {
+        const updated = await this.knex('gift_deliveries')
+            .where({ id, status: from })
+            .update(data);
+        return updated === 1;
+    }
+}
+exports.GiftDeliveryBookshelfRepository = GiftDeliveryBookshelfRepository;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeGiftDeliveryRow = decodeGiftDeliveryRow;
+exports.encodeGiftDelivery = encodeGiftDelivery;
+const case_keys_1 = require("../../lib/case-keys");
+const gift_delivery_schema_1 = require("./gift-delivery-schema");
+function decodeGiftDeliveryRow(input) {
+    return (0, case_keys_1.camelKeys)(gift_delivery_schema_1.DbGiftDelivery.parse(input));
+}
+function encodeGiftDelivery(delivery) {
+    return gift_delivery_schema_1.DbGiftDelivery.parse((0, case_keys_1.snakeKeys)(delivery));
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbGiftDelivery = exports.GiftDeliveryStatusSchema = void 0;
+const zod_1 = require("zod");
+const db_date_1 = require("../../lib/db-date");
+exports.GiftDeliveryStatusSchema = zod_1.z.enum(['pending', 'sending', 'sent', 'failed', 'cancelled']);
+exports.DbGiftDelivery = zod_1.z.object({
+    id: zod_1.z.string(),
+    gift_id: zod_1.z.string(),
+    recipient_email: zod_1.z.string().email(),
+    status: exports.GiftDeliveryStatusSchema.default('pending'),
+    started_at: db_date_1.DbDate.nullable().default(null),
+    email_sent_at: db_date_1.DbDate.nullable().default(null),
+    email_provider_message_id: zod_1.z.string().nullable().default(null)
+});

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

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GiftDeliveryService = void 0;
+const bson_objectid_1 = __importDefault(require("bson-objectid"));
+const logging_1 = __importDefault(require("@tryghost/logging"));
+const send_gift_delivery_event_1 = require("./events/send-gift-delivery-event");
+const constants_1 = require("./constants");
+const DomainEvents = require('@tryghost/domain-events');
+class GiftDeliveryService {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async createForCheckout({ giftId, recipientEmail }, options = {}) {
+        const delivery = {
+            id: new bson_objectid_1.default().toHexString(),
+            giftId,
+            recipientEmail,
+            status: 'pending',
+            startedAt: null,
+            emailSentAt: null,
+            emailProviderMessageId: null
+        };
+        await this.deps.giftDeliveryRepository.create(delivery, options);
+        return delivery.id;
+    }
+    async dispatchForGift(giftId) {
+        const delivery = await this.deps.giftDeliveryRepository.getByGiftId(giftId);
+        if (!delivery || delivery.status !== 'pending') {
+            return delivery?.recipientEmail ?? null;
+        }
+        DomainEvents.dispatch(send_gift_delivery_event_1.SendGiftDeliveryEvent.create({ deliveryId: delivery.id }));
+        return delivery.recipientEmail;
+    }
+    async recoverPending(limit = 1000) {
+        const staleBefore = new Date(Date.now() - constants_1.GIFT_DELIVERY_STALE_AFTER_MS);
+        const deliveries = await this.deps.giftDeliveryRepository.findRecoverableForPurchasedGifts(staleBefore, limit);
+        const result = {
+            sentCount: 0,
+            skippedCount: 0,
+            failedCount: 0
+        };
+        // Sequential on purpose: recovery can find many deliveries at once and each
+        // send holds a mail transport call, so fanning out through events would open
+        // them all concurrently
+        for (const delivery of deliveries) {
+            try {
+                const deliveryResult = await this.send(delivery.id);
+                result[`${deliveryResult}Count`] += 1;
+            }
+            catch (err) {
+                result.failedCount += 1;
+                logging_1.default.error({
+                    event: { name: 'gift_delivery.recovery_failed' },
+                    err,
+                    deliveryId: delivery.id
+                }, 'Failed to recover gift delivery');
+            }
+        }
+        return result;
+    }
+    async cancelPendingForGift(token, options = {}) {
+        return this.deps.giftDeliveryRepository.cancelPendingForGift(token, options);
+    }
+    async send(id) {
+        const now = new Date();
+        const staleBefore = new Date(now.getTime() - constants_1.GIFT_DELIVERY_STALE_AFTER_MS);
+        const delivery = await this.deps.giftDeliveryRepository.tryStartDelivery(id, now, staleBefore);
+        if (!delivery) {
+            return 'skipped';
+        }
+        const gift = await this.deps.giftRepository.getById(delivery.giftId);
+        if (!gift) {
+            logging_1.default.error({
+                event: { name: 'gift_delivery.gift_missing' },
+                deliveryId: delivery.id,
+                giftId: delivery.giftId
+            }, 'Started gift delivery has no gift');
+            await this.deps.giftDeliveryRepository.markFailed(delivery.id);
+            return 'failed';
+        }
+        if (gift.status !== 'purchased') {
+            await this.deps.giftDeliveryRepository.markCancelled(delivery.id);
+            return 'skipped';
+        }
+        if (!gift.buyerEmail || !gift.buyerName) {
+            logging_1.default.error({
+                event: { name: 'gift_delivery.buyer_details_missing' },
+                deliveryId: delivery.id,
+                giftId: delivery.giftId
+            }, 'Gift delivery is missing required buyer details');
+            await this.deps.giftDeliveryRepository.markFailed(delivery.id);
+            return 'failed';
+        }
+        let tier;
+        try {
+            tier = await this.deps.tiersService.api.read(gift.tierId);
+        }
+        catch (err) {
+            logging_1.default.error({
+                event: { name: 'gift_delivery.tier_read_failed' },
+                err,
+                deliveryId: delivery.id,
+                giftId: delivery.giftId,
+                tierId: gift.tierId
+            }, 'Failed to read tier for gift delivery');
+            await this.deps.giftDeliveryRepository.markFailed(delivery.id);
+            return 'failed';
+        }
+        if (!tier) {
+            logging_1.default.error({
+                event: { name: 'gift_delivery.tier_missing' },
+                deliveryId: delivery.id,
+                giftId: delivery.giftId,
+                tierId: gift.tierId
+            }, 'Tier not found for gift delivery');
+            await this.deps.giftDeliveryRepository.markFailed(delivery.id);
+            return 'failed';
+        }
+        let result;
+        try {
+            result = await this.deps.giftEmailService.sendGiftDelivery({
+                recipientEmail: delivery.recipientEmail,
+                recipientName: gift.recipientName,
+                buyerEmail: gift.buyerEmail,
+                buyerName: gift.buyerName,
+                personalMessage: gift.personalMessage,
+                token: gift.token,
+                tierName: tier.name,
+                benefits: tier.toJSON().benefits,
+                cadence: gift.cadence,
+                duration: gift.duration,
+                expiresAt: gift.expiresAt
+            });
+        }
+        catch (err) {
+            logging_1.default.error({
+                event: { name: 'gift_delivery.acceptance_failed' },
+                // The bulk mailer rejects with {error, messageData}; the rendered
+                // message and recipient must stay out of the logs
+                err: isMailgunRejection(err) ? err.error : err,
+                deliveryId: delivery.id,
+                giftId: delivery.giftId
+            }, 'Mail transport did not accept gift delivery');
+            await this.deps.giftDeliveryRepository.markFailed(delivery.id);
+            return 'failed';
+        }
+        const sentAt = new Date();
+        let persisted;
+        let cancelledDuringSend = false;
+        try {
+            persisted = await this.deps.giftDeliveryRepository.markSent(delivery.id, sentAt, result.providerMessageId);
+        }
+        catch (err) {
+            logging_1.default.warn({
+                event: { name: 'gift_delivery.acceptance_persistence.retrying' },
+                err,
+                deliveryId: delivery.id
+            }, 'Retrying accepted gift delivery persistence');
+            try {
+                persisted = await this.deps.giftDeliveryRepository.markSent(delivery.id, sentAt, result.providerMessageId);
+            }
+            catch (retryErr) {
+                logging_1.default.error({
+                    event: { name: 'gift_delivery.acceptance_persistence.failed' },
+                    err: retryErr,
+                    deliveryId: delivery.id
+                }, 'Failed to persist accepted gift delivery');
+                try {
+                    await this.deps.giftDeliveryRepository.markFailed(delivery.id);
+                }
+                catch (markFailedErr) {
+                    logging_1.default.error({
+                        event: { name: 'gift_delivery.acceptance_terminal_persistence.failed' },
+                        err: markFailedErr,
+                        deliveryId: delivery.id
+                    }, 'Failed to move accepted gift delivery out of recovery');
+                }
+                return 'failed';
+            }
+        }
+        if (!persisted) {
+            cancelledDuringSend = await this.deps.giftDeliveryRepository.recordCancelledAcceptance(delivery.id, sentAt, result.providerMessageId);
+        }
+        if (persisted) {
+            return 'sent';
+        }
+        if (cancelledDuringSend) {
+            logging_1.default.info({
+                event: { name: 'gift_delivery.cancelled_during_send' },
+                deliveryId: delivery.id,
+                giftId: delivery.giftId
+            }, 'Gift delivery was cancelled while its email was in flight');
+            return 'skipped';
+        }
+        logging_1.default.error({
+            event: { name: 'gift_delivery.acceptance_persistence.failed' },
+            deliveryId: delivery.id
+        }, 'Failed to persist accepted gift delivery');
+        return 'failed';
+    }
+}
+exports.GiftDeliveryService = GiftDeliveryService;
+function isMailgunRejection(err) {
+    return typeof err === 'object' && err !== null && 'error' in err && 'messageData' in err;
+}

package/core/server/services/gifts/gift-email-renderer.js

@@ -9,11 +9,13 @@ const node_path_1 = __importDefault(require("node:path"));
 const handlebars_1 = __importDefault(require("handlebars"));
 const gift_purchase_confirmation_1 = require("./email-templates/gift-purchase-confirmation");
 const gift_reminder_1 = require("./email-templates/gift-reminder");
+const gift_delivery_1 = require("./email-templates/gift-delivery");
 class GiftEmailRenderer {
     handlebars;
     t;
     purchaseConfirmationTemplate = null;
     reminderTemplate = null;
+    deliveryTemplate = null;
     constructor({ t }) {
         this.t = t;
         this.handlebars = handlebars_1.default.create();
@@ -39,11 +41,21 @@ class GiftEmailRenderer {
             text: (0, gift_reminder_1.renderText)(data, this.t)
         };
     }
+    async renderDelivery(data) {
+        if (!this.deliveryTemplate) {
+            const source = await node_fs_1.promises.readFile(node_path_1.default.join(__dirname, './email-templates/gift-delivery.hbs'), 'utf8');
+            this.deliveryTemplate = this.handlebars.compile(source);
+        }
+        return {
+            html: this.deliveryTemplate(data),
+            text: (0, gift_delivery_1.renderText)(data, this.t)
+        };
+    }
     registerTemplateHelpers() {
         this.handlebars.registerHelper('t', (key, options) => {
             const hash = options?.hash || {};
             const escapedHash = Object.entries(hash).reduce((acc, [name, value]) => {
-                acc[name] = this.htmlSafeInterpolationValue(value);
+                acc[name] = typeof value === 'number' ? value : this.htmlSafeInterpolationValue(value);
                 return acc;
             }, {});
             return new handlebars_1.default.SafeString(this.t(key, {

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

@@ -1,18 +1,27 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GiftEmailService = void 0;
 const gift_email_renderer_1 = require("./gift-email-renderer");
+const color_utils_1 = require("@tryghost/color-utils");
+const errors_1 = __importDefault(require("@tryghost/errors"));
+const mailgun_message_id_1 = require("../lib/mailgun-message-id");
 const DEFAULT_DATE_LOCALE = 'en-gb';
+const DEFAULT_ACCENT_COLOR = '#15212A';
 class GiftEmailService {
-    mailer;
+    transactionalMailer;
+    bulkMailer;
     settingsCache;
     urlUtils;
     getFromAddress;
     blogIcon;
     renderer;
     t;
-    constructor({ mailer, settingsCache, urlUtils, getFromAddress, blogIcon, t }) {
-        this.mailer = mailer;
+    constructor({ transactionalMailer, bulkMailer, settingsCache, urlUtils, getFromAddress, blogIcon, t }) {
+        this.transactionalMailer = transactionalMailer;
+        this.bulkMailer = bulkMailer;
         this.settingsCache = settingsCache;
         this.urlUtils = urlUtils;
         this.getFromAddress = getFromAddress;
@@ -28,14 +37,22 @@ class GiftEmailService {
             return '';
         }
     }
-    getCadenceLabel(cadence, duration) {
-        if (duration === 1) {
-            return cadence === 'year' ? this.t('one-year') : this.t('one-month');
+    get accentColor() {
+        return this.settingsCache.get('accent_color') || DEFAULT_ACCENT_COLOR;
+    }
+    mixAccentColor(target, accentWeight, fallback) {
+        try {
+            return (0, color_utils_1.Color)(target).mix((0, color_utils_1.Color)(this.accentColor), accentWeight).hex().toLowerCase();
         }
-        if (cadence === 'year') {
-            return this.t('{count} year', { count: duration });
+        catch {
+            return fallback;
         }
-        return this.t('{count} month', { count: duration });
+    }
+    get accentTint() {
+        return this.mixAccentColor('#FFFFFF', 0.07, '#F4F5F6');
+    }
+    get accentShade() {
+        return this.mixAccentColor('#15212A', 0.72, '#738A94');
     }
     formatDate(date) {
         const locale = this.settingsCache.get('locale') || DEFAULT_DATE_LOCALE;
@@ -45,12 +62,11 @@ class GiftEmailService {
             year: 'numeric'
         }).format(date);
     }
-    async sendPurchaseConfirmation({ buyerEmail, token, tierName, cadence, duration, expiresAt }) {
+    async sendPurchaseConfirmation({ buyerEmail, token, tierName, cadence, duration, expiresAt, recipientEmail = null }) {
         const siteDomain = this.siteDomain;
         const siteUrl = this.urlUtils.getSiteUrl();
         const siteTitle = this.settingsCache.get('title') ?? siteDomain;
         const giftLink = `${siteUrl.replace(/\/$/, '')}/gift/${token}`;
-        const cadenceLabel = this.getCadenceLabel(cadence, duration);
         const { html, text } = await this.renderer.renderPurchaseConfirmation({
             siteTitle,
             siteUrl,
@@ -60,18 +76,21 @@ class GiftEmailService {
             toEmail: buyerEmail,
             gift: {
                 tierName,
-                cadenceLabel,
+                duration,
+                isMonthly: cadence === 'month',
                 link: giftLink,
-                expiresAt: this.formatDate(expiresAt)
+                expiresAt: this.formatDate(expiresAt),
+                recipientEmail
             }
         });
-        await this.mailer.send({
+        await this.transactionalMailer.send({
             to: buyerEmail,
-            subject: this.t('Your gift is ready'),
+            subject: recipientEmail ? this.t('Your gift is on its way') : this.t('Your gift is ready'),
             html,
             text,
             from: this.getFromAddress(),
-            forceTextContent: true
+            forceTextContent: true,
+            disableTracking: true
         });
     }
     async sendReminder({ memberEmail, memberName, tierName, consumesAt }) {
@@ -94,7 +113,7 @@ class GiftEmailService {
                 manageSubscriptionUrl
             }
         });
-        await this.mailer.send({
+        await this.transactionalMailer.send({
             to: memberEmail,
             subject: this.t('Your gift subscription is ending soon'),
             html,
@@ -103,5 +122,66 @@ class GiftEmailService {
             forceTextContent: true
         });
     }
+    async sendGiftDelivery({ recipientEmail, recipientName, buyerEmail, buyerName, personalMessage, token, tierName, benefits, cadence, duration, expiresAt }) {
+        const siteDomain = this.siteDomain;
+        const siteUrl = this.urlUtils.getSiteUrl();
+        const siteTitle = this.settingsCache.get('title') ?? siteDomain;
+        const giftLink = `${siteUrl.replace(/\/$/, '')}/gift/${token}`;
+        const { html, text } = await this.renderer.renderDelivery({
+            siteTitle,
+            siteUrl,
+            siteIconUrl: this.blogIcon.getIconUrl({ absolute: true, fallbackToDefault: false }),
+            siteDomain,
+            accentColor: this.accentColor,
+            accentTint: this.accentTint,
+            accentShade: this.accentShade,
+            toEmail: recipientEmail,
+            buyerEmail,
+            buyerName,
+            recipientName,
+            personalMessage,
+            gift: {
+                tierName,
+                benefits,
+                duration,
+                isMonthly: cadence === 'month',
+                link: giftLink,
+                expiresAt: this.formatDate(expiresAt)
+            }
+        });
+        const subject = this.t('{buyerName} sent you a gift', {
+            buyerName,
+            interpolation: { escapeValue: false }
+        });
+        if (!this.bulkMailer.isConfigured()) {
+            await this.transactionalMailer.send({
+                to: recipientEmail,
+                subject,
+                html,
+                text,
+                from: this.getFromAddress(),
+                forceTextContent: true,
+                tags: ['gift-delivery'],
+                disableTracking: true
+            });
+            return { providerMessageId: null };
+        }
+        const response = await this.bulkMailer.send({
+            subject,
+            html,
+            plaintext: text,
+            from: this.getFromAddress(),
+            tags: ['gift-delivery'],
+            disable_tracking: true
+        }, { [recipientEmail]: {} }, []);
+        const providerMessageId = (0, mailgun_message_id_1.getMailgunMessageId)(response) ?? null;
+        if (!providerMessageId) {
+            throw new errors_1.default.EmailError({
+                message: 'Bulk Mailgun did not accept gift delivery',
+                code: 'EMAIL_NOT_ACCEPTED'
+            });
+        }
+        return { providerMessageId };
+    }
 }
 exports.GiftEmailService = GiftEmailService;

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

@@ -4,7 +4,7 @@ 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']);
+exports.GiftStatusSchema = zod_1.z.enum(['payment_pending', '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
@@ -12,20 +12,24 @@ exports.GiftStatusSchema = zod_1.z.enum(['purchased', 'redeemed', 'consumed', 'e
  */
 exports.DbGift = zod_1.z.object({
     token: zod_1.z.string(),
-    buyer_email: zod_1.z.string(),
+    buyer_email: zod_1.z.string().nullable(),
     buyer_member_id: zod_1.z.string().nullable(),
+    buyer_name: zod_1.z.string().nullable().default(null),
+    recipient_name: zod_1.z.string().nullable().default(null),
+    personal_message: zod_1.z.string().nullable().default(null),
     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(),
+    stripe_checkout_session_id: zod_1.z.string().nullable(),
+    stripe_payment_intent_id: zod_1.z.string().nullable(),
+    checkout_started_at: db_date_1.DbDate.nullable().default(null),
     consumes_at: db_date_1.DbDate.nullable(),
-    expires_at: db_date_1.DbDate,
+    expires_at: db_date_1.DbDate.nullable(),
     status: exports.GiftStatusSchema,
-    purchased_at: db_date_1.DbDate,
+    purchased_at: db_date_1.DbDate.nullable(),
     redeemed_at: db_date_1.DbDate.nullable(),
     consumed_at: db_date_1.DbDate.nullable(),
     expired_at: db_date_1.DbDate.nullable(),