ghost 6.54.1 → 6.56.0

package/core/server/services/email-service/newsletter-email-event-storage.js

@@ -1,4 +1,5 @@
 const moment = require('moment-timezone');
+const errors = require('@tryghost/errors');
 const logging = require('@tryghost/logging');
 const config = require('../../../shared/config');
 
@@ -177,11 +178,20 @@ class NewsletterEmailEventStorage {
 
     async handleUnsubscribed(event) {
         try {
-            // Unsubscribe member from the specific newsletter
-            const newsletters = await this.findNewslettersToKeep(event);
-            await this.#membersRepository.update({newsletters}, {id: event.memberId});
+            const result = await this.findNewslettersToKeep(event);
 
-            // Remove member from Mailgun's suppression list
+            if (result.status === 'failed') {
+                // Leave Mailgun's suppression in place: these events are fetched
+                // once and never retried, so it is the only remaining protection.
+                return;
+            }
+
+            if (result.status === 'ok') {
+                await this.#membersRepository.update({newsletters: result.newsletters}, {id: event.memberId});
+            }
+
+            // Remove member from Mailgun's suppression list, only once the local
+            // record reflects the unsubscribe or there is no member left to protect
             await this.#emailSuppressionList.removeUnsubscribe(event.email);
         } catch (err) {
             logging.error(err);
@@ -205,22 +215,43 @@ class NewsletterEmailEventStorage {
         }
     }
 
+    /**
+     * @typedef {{status: 'ok', newsletters: {id: string}[]}
+     *     | {status: 'no-member'}
+     *     | {status: 'failed'}} FindNewslettersToKeepResult
+     */
+
+    /**
+     * @param {import('./events/email-unsubscribed-event')} event
+     * @returns {Promise<FindNewslettersToKeepResult>}
+     */
     async findNewslettersToKeep(event) {
         try {
-            const member = await this.#membersRepository.get({email: event.email}, {
+            const member = await this.#membersRepository.get({id: event.memberId}, {
                 withRelated: ['newsletters']
             });
+
+            if (!member) {
+                return {status: 'no-member'};
+            }
+
             const existingNewsletters = member.related('newsletters');
 
             const email = await this.#models.Email.findOne({id: event.emailId});
             const newsletterToRemove = email.get('newsletter_id');
 
-            return existingNewsletters.models.filter(newsletter => newsletter.id !== newsletterToRemove).map((n) => {
-                return {id: n.id};
-            });
+            return {
+                status: 'ok',
+                newsletters: existingNewsletters.models.filter(newsletter => newsletter.id !== newsletterToRemove).map((n) => {
+                    return {id: n.id};
+                })
+            };
         } catch (err) {
-            logging.error(err);
-            return [];
+            logging.error(new errors.InternalServerError({
+                message: `Could not resolve newsletters to keep for unsubscribe event (member ${event.memberId}, email ${event.emailId})`,
+                err
+            }));
+            return {status: 'failed'};
         }
     }
 

package/core/server/services/gift-links/CONTEXT.md

@@ -0,0 +1,9 @@
+# Gift Links
+
+Gift Links covers shareable access to individual protected posts and pages without creating a membership.
+
+## Language
+
+**Gift Link**:
+A revocable link that grants its holder access to one protected post or page. It does not create or redeem a gift subscription.
+_Avoid_: Redemption link, gift-subscription link

package/core/server/services/gifts/CONTEXT.md

@@ -0,0 +1,55 @@
+# Gift Subscriptions
+
+Gift Subscriptions covers prepaid, fixed-duration membership access intended to be shared and claimed. Its language spans gift purchase, gift redemption, gift expiration, gift consumption, and gift continuation into a paid subscription.
+
+## Language
+
+### Roles
+
+**Buyer**:
+The person who pays for a gift subscription. A buyer need not be a member and may also become the redeemer if eligible.
+_Avoid_: Purchaser, recipient, redeemer
+
+**Redeemer**:
+The member who claims a gift subscription and receives its access. The redeemer is determined at redemption, not purchase.
+_Avoid_: Recipient, buyer
+
+### Purchase and claim
+
+**Gift subscription**:
+A prepaid, non-renewing entitlement to one membership tier for a fixed period. It begins when claimed rather than when purchased.
+_Avoid_: Gift membership, recurring subscription
+
+**Gift purchase**:
+A one-time purchase that creates a gift subscription for the buyer to share.
+_Avoid_: Gift checkout
+
+**Redemption link**:
+A single-use, time-limited link through which a purchased gift subscription can be claimed.
+_Avoid_: Gift Link
+
+**Gift redemption**:
+The act of claiming an eligible gift subscription. The member who claims it becomes the redeemer and gifted access begins at that point.
+_Avoid_: Gift activation
+
+### Time and lifecycle
+
+**Gift duration**:
+The total length of gifted access, measured from redemption.
+_Avoid_: Gift cadence, billing period
+
+**Gift cadence**:
+The monthly or yearly membership price basis used to value a gift subscription. It does not make the gift recurring.
+_Avoid_: Gift duration, renewal interval
+
+**Gift expiration**:
+The end of the claim window for a purchased gift subscription that was never redeemed.
+_Avoid_: Gift consumption
+
+**Gift consumption**:
+The end of a redeemed gift subscription's role in providing access, either when its duration finishes or a paid subscription takes over.
+_Avoid_: Gift expiration, cancellation
+
+**Gift continuation**:
+Starting a paid subscription from gifted access while carrying the remaining gifted time forward before billing begins.
+_Avoid_: Gift renewal

package/core/server/services/gifts/README.md

@@ -0,0 +1,28 @@
+# Gifts
+
+This module owns the gift-subscription journey. Its interface is
+capability-oriented; callers do not receive `Gift` entities, Bookshelf models,
+transactions, or Stripe objects.
+
+## Interface
+
+- `startCheckout(input)` owns the `giftSubCustomization` flag, duration
+  catalogue, Portal plan gate, tier/cadence validation, authoritative price,
+  token, success parameters, metadata, customer, and one-time payment.
+- `preparePaidContinuation(input)` validates an active gift and returns the
+  stable tier/cadence/trial decision consumed by the normal subscription
+  checkout path.
+- `getRedeemable(input)` and `redeem(input)` return the public redemption DTO.
+- `completePurchase(input)` and `handlePaymentRefund(input)` accept normalized
+  payment outcomes.
+- `handlePaidSubscriptionActivation(memberId)` consumes gift time when a paid
+  subscription takes over.
+- `getMemberPresentations(memberIds)`, `getPreview(token)`,
+  `browsePurchaseEvents(...)`, and `browseRedemptionEvents(...)` expose
+  stable read models.
+- `processReminders()`, `processConsumed()`, and `processExpired()` own due
+  lifecycle work; scheduler and HTTP triggers remain adapters.
+- `reassignRedeemer(...)` is the import capability.
+
+The `Gift`, repository, Bookshelf query, Stripe checkout, email, scheduling,
+and notification collaborators are internal adapters.

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

@@ -5,7 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GiftBookshelfRepository = void 0;
 const errors_1 = __importDefault(require("@tryghost/errors"));
-const gift_1 = require("./gift");
+const mongo_utils_1 = require("@tryghost/mongo-utils");
+const gift_codec_1 = require("./gift-codec");
 class GiftBookshelfRepository {
     model;
     constructor({ GiftModel }) {
@@ -60,6 +61,26 @@ class GiftBookshelfRepository {
         }
         return map;
     }
+    browsePurchaseEvents(options = {}, filter) {
+        return this.browseEvents({
+            options,
+            filter,
+            type: 'gift_purchase_event',
+            relation: 'buyer',
+            memberIdColumn: 'buyer_member_id',
+            dateColumn: 'purchased_at'
+        });
+    }
+    browseRedemptionEvents(options = {}, filter) {
+        return this.browseEvents({
+            options,
+            filter,
+            type: 'gift_redemption_event',
+            relation: 'redeemer',
+            memberIdColumn: 'redeemer_member_id',
+            dateColumn: 'redeemed_at'
+        });
+    }
     async findPendingConsumption() {
         const now = new Date();
         const collection = await this.model.findAll({
@@ -111,53 +132,52 @@ class GiftBookshelfRepository {
         return await this.model.transaction(callback);
     }
     toRow(gift) {
-        return {
-            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
-        };
+        return (0, gift_codec_1.encodeGift)(gift);
     }
     toGift(model) {
-        const json = model.toJSON();
-        return new gift_1.Gift({
-            token: json.token,
-            buyerEmail: json.buyer_email,
-            buyerMemberId: json.buyer_member_id,
-            redeemerMemberId: json.redeemer_member_id,
-            tierId: json.tier_id,
-            cadence: json.cadence,
-            duration: json.duration,
-            currency: json.currency,
-            amount: json.amount,
-            stripeCheckoutSessionId: json.stripe_checkout_session_id,
-            stripePaymentIntentId: json.stripe_payment_intent_id,
-            consumesAt: json.consumes_at,
-            expiresAt: json.expires_at,
-            status: json.status,
-            purchasedAt: json.purchased_at,
-            redeemedAt: json.redeemed_at,
-            consumedAt: json.consumed_at,
-            expiredAt: json.expired_at,
-            refundedAt: json.refunded_at,
-            consumesSoonReminderSentAt: json.consumes_soon_reminder_sent_at ?? null
+        return (0, gift_codec_1.decodeGiftRow)(model.toJSON());
+    }
+    async browseEvents({ options, filter, type, relation, memberIdColumn, dateColumn }) {
+        const replaceCustomFilter = (existingFilter) => (0, mongo_utils_1.replaceFilters)(existingFilter, {
+            custom: filter
         });
+        const queryOptions = {
+            ...options,
+            withRelated: [relation, 'tier'],
+            filter: `${memberIdColumn}:-null+custom:true`,
+            useBasicCount: true,
+            mongoTransformer: (0, mongo_utils_1.chainTransformers)(replaceCustomFilter, ...(0, mongo_utils_1.mapKeys)({
+                'data.created_at': dateColumn,
+                'data.member_id': memberIdColumn
+            }))
+        };
+        if (typeof queryOptions.order === 'string') {
+            queryOptions.order = queryOptions.order.replace(/created_at/g, dateColumn);
+        }
+        if (!this.model.findPage) {
+            throw new errors_1.default.InternalServerError({ message: 'Gift model does not support paginated event queries.' });
+        }
+        const { data: models, meta } = await this.model.findPage(queryOptions);
+        return {
+            data: models.map((model) => {
+                const json = model.toJSON(queryOptions);
+                return {
+                    type,
+                    data: {
+                        id: json.id,
+                        member: json[relation] || null,
+                        member_id: json[memberIdColumn],
+                        tier_name: json.tier?.name,
+                        cadence: json.cadence,
+                        duration: json.duration,
+                        amount: json.amount,
+                        currency: json.currency,
+                        created_at: json[dateColumn]
+                    }
+                };
+            }),
+            meta
+        };
     }
 }
 exports.GiftBookshelfRepository = GiftBookshelfRepository;

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

@@ -1,10 +1,100 @@
 import errors from '@tryghost/errors';
-import {Gift, type GiftCadence, type GiftStatus} from './gift';
-import type {FindPendingReminderOptions, GiftRepository, RepositoryTransactionOptions} from './gift-repository';
+import {chainTransformers, mapKeys, replaceFilters} from '@tryghost/mongo-utils';
+import type {Knex} from 'knex';
+import {Gift} from './gift';
+import {decodeGiftRow, encodeGift} from './gift-codec';
+import type {GiftCadence, GiftRow} from './gift-schema';
+
+type ParsedNqlFilter = unknown;
+
+export interface GiftEventBrowseOptions {
+    filter?: string;
+    limit?: number | 'all';
+    order?: string;
+    page?: number;
+}
+
+export interface Pagination {
+    page: number;
+    pages: number;
+    limit: number | 'all';
+    total: number;
+    prev: number | null;
+    next: number | null;
+}
+
+export interface GiftEventData {
+    id: string;
+    member: Record<string, unknown> | null;
+    member_id: string | null;
+    tier_name?: string;
+    cadence: GiftCadence;
+    duration: number;
+    amount: number;
+    currency: string;
+    created_at: Date | string | null;
+}
+
+export interface GiftEventPage {
+    data: Array<{
+        type: 'gift_purchase_event' | 'gift_redemption_event';
+        data: GiftEventData;
+    }>;
+    meta: {
+        pagination?: Pagination;
+    };
+}
+
+export interface RepositoryTransactionOptions {
+    transacting?: Knex.Transaction;
+    forUpdate?: boolean;
+}
+
+export interface FindPendingReminderOptions {
+    now: Date;
+    reminderLeadMs: number;
+    reminderFloorMs: number;
+    transacting?: Knex.Transaction;
+}
+
+export interface GiftRepository {
+    existsByCheckoutSessionId(checkoutSessionId: string): Promise<boolean>;
+    getById(id: string, options?: RepositoryTransactionOptions): Promise<Gift | null>;
+    getByToken(token: string, options?: RepositoryTransactionOptions): Promise<Gift | null>;
+    getByPaymentIntentId(paymentIntentId: string): Promise<Gift | null>;
+    findPendingConsumption(): Promise<Gift[]>;
+    findPendingExpiration(): Promise<Gift[]>;
+    findPendingReminder(options: FindPendingReminderOptions): Promise<Gift[]>;
+    findUnsentReminders(): Promise<Gift[]>;
+    getActiveByMember(memberId: string, options?: RepositoryTransactionOptions): Promise<Gift | null>;
+    getActiveByMembers(memberIds: string[], options?: RepositoryTransactionOptions): Promise<Map<string, Gift>>;
+    browsePurchaseEvents(options?: GiftEventBrowseOptions, filter?: ParsedNqlFilter): Promise<GiftEventPage>;
+    browseRedemptionEvents(options?: GiftEventBrowseOptions, filter?: ParsedNqlFilter): Promise<GiftEventPage>;
+    create(gift: Gift, options?: RepositoryTransactionOptions): Promise<void>;
+    update(gift: Gift, options?: RepositoryTransactionOptions): Promise<void>;
+    transaction<T>(callback: (transacting: Knex.Transaction) => Promise<T>): Promise<T>;
+}
+
+type BookshelfSaveOptions = RepositoryTransactionOptions & {
+    autoRefresh?: boolean;
+    method?: 'update';
+    patch?: boolean;
+};
+
+type GiftEventQueryOptions = GiftEventBrowseOptions & {
+    withRelated: Array<'buyer' | 'redeemer' | 'tier'>;
+    filter: string;
+    useBasicCount: boolean;
+    mongoTransformer: (filter: ParsedNqlFilter) => ParsedNqlFilter;
+};
+
+type BookshelfFindOptions = RepositoryTransactionOptions & {
+    filter?: string;
+    require?: boolean;
+};
 
 type BookshelfDocument<T> = {
-    save(data: Partial<T>, options?: unknown): Promise<unknown>;
-    set(data: Partial<T>): void;
+    save(data: Partial<T>, options?: BookshelfSaveOptions): Promise<BookshelfDocument<T>>;
     toJSON(): T;
 };
 
@@ -12,35 +102,31 @@ type BookshelfCollection<T> = {
     models: BookshelfDocument<T>[];
 };
 
-type BookshelfModel<T> = {
-    add(data: Partial<T>, unfilteredOptions?: unknown): Promise<T>;
-    transaction<R>(callback: (transacting: unknown) => Promise<R>): Promise<R>;
-    findOne(data: Record<string, unknown>, unfilteredOptions?: unknown): Promise<BookshelfDocument<T> | null>;
-    findAll(unfilteredOptions?: unknown): Promise<BookshelfCollection<T>>;
-};
-
-type GiftRow = {
+type GiftEventBookshelfRow = {
     id: string;
-    token: string;
-    buyer_email: string;
     buyer_member_id: string | null;
     redeemer_member_id: string | null;
-    tier_id: string;
+    buyer?: Record<string, unknown> | null;
+    redeemer?: Record<string, unknown> | null;
+    tier?: {name?: string} | null;
     cadence: GiftCadence;
     duration: number;
-    currency: string;
     amount: number;
-    stripe_checkout_session_id: string;
-    stripe_payment_intent_id: string;
-    consumes_at: Date | null;
-    expires_at: Date;
-    status: GiftStatus;
-    purchased_at: Date;
-    redeemed_at: Date | null;
-    consumed_at: Date | null;
-    expired_at: Date | null;
-    refunded_at: Date | null;
-    consumes_soon_reminder_sent_at: Date | null;
+    currency: string;
+    purchased_at: Date | string;
+    redeemed_at: Date | string | null;
+};
+
+type GiftEventBookshelfDocument = {
+    toJSON(options?: GiftEventQueryOptions): GiftEventBookshelfRow;
+};
+
+type BookshelfModel<T> = {
+    add(data: Partial<T>, options?: RepositoryTransactionOptions): Promise<BookshelfDocument<T>>;
+    transaction<R>(callback: (transacting: Knex.Transaction) => Promise<R>): Promise<R>;
+    findOne(data: Partial<T> & {id?: string}, options?: BookshelfFindOptions): Promise<BookshelfDocument<T> | null>;
+    findAll(options?: BookshelfFindOptions): Promise<BookshelfCollection<T>>;
+    findPage(options: GiftEventQueryOptions): Promise<{data: GiftEventBookshelfDocument[]; meta: GiftEventPage['meta']}>;
 };
 
 type GiftBookshelfModel = BookshelfModel<GiftRow>;
@@ -116,6 +202,28 @@ export class GiftBookshelfRepository implements GiftRepository {
         return map;
     }
 
+    browsePurchaseEvents(options: GiftEventBrowseOptions = {}, filter?: ParsedNqlFilter): Promise<GiftEventPage> {
+        return this.browseEvents({
+            options,
+            filter,
+            type: 'gift_purchase_event',
+            relation: 'buyer',
+            memberIdColumn: 'buyer_member_id',
+            dateColumn: 'purchased_at'
+        });
+    }
+
+    browseRedemptionEvents(options: GiftEventBrowseOptions = {}, filter?: ParsedNqlFilter): Promise<GiftEventPage> {
+        return this.browseEvents({
+            options,
+            filter,
+            type: 'gift_redemption_event',
+            relation: 'redeemer',
+            memberIdColumn: 'redeemer_member_id',
+            dateColumn: 'redeemed_at'
+        });
+    }
+
     async findPendingConsumption(): Promise<Gift[]> {
         const now = new Date();
 
@@ -179,59 +287,80 @@ export class GiftBookshelfRepository implements GiftRepository {
         });
     }
 
-    async transaction<T>(callback: (transacting: unknown) => Promise<T>): Promise<T> {
+    async transaction<T>(callback: (transacting: Knex.Transaction) => Promise<T>): Promise<T> {
         return await this.model.transaction(callback);
     }
 
-    private toRow(gift: Gift): Omit<GiftRow, 'id'> {
-        return {
-            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
-        };
+    private toRow(gift: Gift): GiftRow {
+        return encodeGift(gift);
     }
 
     private toGift(model: BookshelfDocument<GiftRow>): Gift {
-        const json = model.toJSON();
-
-        return new Gift({
-            token: json.token,
-            buyerEmail: json.buyer_email,
-            buyerMemberId: json.buyer_member_id,
-            redeemerMemberId: json.redeemer_member_id,
-            tierId: json.tier_id,
-            cadence: json.cadence,
-            duration: json.duration,
-            currency: json.currency,
-            amount: json.amount,
-            stripeCheckoutSessionId: json.stripe_checkout_session_id,
-            stripePaymentIntentId: json.stripe_payment_intent_id,
-            consumesAt: json.consumes_at,
-            expiresAt: json.expires_at,
-            status: json.status,
-            purchasedAt: json.purchased_at,
-            redeemedAt: json.redeemed_at,
-            consumedAt: json.consumed_at,
-            expiredAt: json.expired_at,
-            refundedAt: json.refunded_at,
-            consumesSoonReminderSentAt: json.consumes_soon_reminder_sent_at ?? null
+        return decodeGiftRow(model.toJSON());
+    }
+
+    private async browseEvents({
+        options,
+        filter,
+        type,
+        relation,
+        memberIdColumn,
+        dateColumn
+    }: {
+        options: GiftEventBrowseOptions;
+        filter?: ParsedNqlFilter;
+        type: 'gift_purchase_event' | 'gift_redemption_event';
+        relation: 'buyer' | 'redeemer';
+        memberIdColumn: 'buyer_member_id' | 'redeemer_member_id';
+        dateColumn: 'purchased_at' | 'redeemed_at';
+    }): Promise<GiftEventPage> {
+        const replaceCustomFilter = (existingFilter: ParsedNqlFilter): ParsedNqlFilter => replaceFilters(existingFilter, {
+            custom: filter
         });
+        const queryOptions: GiftEventQueryOptions = {
+            ...options,
+            withRelated: [relation, 'tier'],
+            filter: `${memberIdColumn}:-null+custom:true`,
+            useBasicCount: true,
+            mongoTransformer: chainTransformers(
+                replaceCustomFilter,
+                ...mapKeys({
+                    'data.created_at': dateColumn,
+                    'data.member_id': memberIdColumn
+                })
+            )
+        };
+
+        if (typeof queryOptions.order === 'string') {
+            queryOptions.order = queryOptions.order.replace(/created_at/g, dateColumn);
+        }
+
+        if (!this.model.findPage) {
+            throw new errors.InternalServerError({message: 'Gift model does not support paginated event queries.'});
+        }
+
+        const {data: models, meta} = await this.model.findPage(queryOptions);
+
+        return {
+            data: models.map((model) => {
+                const json = model.toJSON(queryOptions);
+
+                return {
+                    type,
+                    data: {
+                        id: json.id,
+                        member: json[relation] || null,
+                        member_id: json[memberIdColumn],
+                        tier_name: json.tier?.name,
+                        cadence: json.cadence,
+                        duration: json.duration,
+                        amount: json.amount,
+                        currency: json.currency,
+                        created_at: json[dateColumn]
+                    }
+                };
+            }),
+            meta
+        };
     }
 }

package/core/server/services/gifts/gift-checkout-adapter.js

@@ -0,0 +1,59 @@
+const logging = require('@tryghost/logging');
+
+/**
+ * Stripe and Bookshelf adapter used only by the gifts module.
+ *
+ * The module interface deals in stable member/customer IDs. Stripe customer
+ * objects and Bookshelf models stay on this side of the seam.
+ */
+module.exports = class GiftCheckoutAdapter {
+    constructor({StripeCustomerModel, getStripeApi}) {
+        this.StripeCustomerModel = StripeCustomerModel;
+        this.getStripeApi = getStripeApi;
+    }
+
+    async getCustomerId({memberId, email, name}) {
+        if (!memberId) {
+            return null;
+        }
+
+        const rows = await this.StripeCustomerModel.where({
+            member_id: memberId
+        }).query().select('customer_id');
+
+        for (const row of rows) {
+            try {
+                const customer = await this.getStripeApi().getCustomer(row.customer_id);
+                if (!customer.deleted) {
+                    return customer.id;
+                }
+            } catch (err) {
+                logging.warn(err);
+            }
+        }
+
+        const customer = await this.getStripeApi().createCustomer({
+            email,
+            name
+        });
+
+        await this.StripeCustomerModel.add({
+            member_id: memberId,
+            customer_id: customer.id,
+            email: customer.email,
+            name: customer.name
+        });
+
+        return customer.id;
+    }
+
+    async createSession(data) {
+        const {customerId, ...sessionData} = data;
+        const session = await this.getStripeApi().createGiftCheckoutSession({
+            ...sessionData,
+            customer: customerId ? {id: customerId} : null
+        });
+
+        return session.url;
+    }
+};