ghost 6.57.1 → 6.58.0

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

@@ -1,366 +0,0 @@
-import errors from '@tryghost/errors';
-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?: BookshelfSaveOptions): Promise<BookshelfDocument<T>>;
-    toJSON(): T;
-};
-
-type BookshelfCollection<T> = {
-    models: BookshelfDocument<T>[];
-};
-
-type GiftEventBookshelfRow = {
-    id: string;
-    buyer_member_id: string | null;
-    redeemer_member_id: string | null;
-    buyer?: Record<string, unknown> | null;
-    redeemer?: Record<string, unknown> | null;
-    tier?: {name?: string} | null;
-    cadence: GiftCadence;
-    duration: number;
-    amount: number;
-    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>;
-
-export class GiftBookshelfRepository implements GiftRepository {
-    private readonly model: GiftBookshelfModel;
-
-    constructor({GiftModel}: {GiftModel: GiftBookshelfModel}) {
-        this.model = GiftModel;
-    }
-
-    async existsByCheckoutSessionId(checkoutSessionId: string): Promise<boolean> {
-        const existing = await this.model.findOne({
-            stripe_checkout_session_id: checkoutSessionId
-        }, {require: false});
-
-        return !!existing;
-    }
-
-    async getById(id: string, options: RepositoryTransactionOptions = {}): Promise<Gift | null> {
-        const model = await this.model.findOne({
-            id
-        }, {require: false, ...options});
-
-        return model ? this.toGift(model) : null;
-    }
-
-    async getByToken(token: string, options: RepositoryTransactionOptions = {}): Promise<Gift | null> {
-        const model = await this.model.findOne({
-            token
-        }, {require: false, ...options});
-
-        return model ? this.toGift(model) : null;
-    }
-
-    async getByPaymentIntentId(paymentIntentId: string): Promise<Gift | null> {
-        const model = await this.model.findOne({
-            stripe_payment_intent_id: paymentIntentId
-        }, {require: false});
-
-        return model ? this.toGift(model) : null;
-    }
-
-    async getActiveByMember(memberId: string, options: RepositoryTransactionOptions = {}): Promise<Gift | null> {
-        const model = await this.model.findOne({
-            redeemer_member_id: memberId,
-            status: 'redeemed'
-        }, {require: false, ...options});
-
-        return model ? this.toGift(model) : null;
-    }
-
-    async getActiveByMembers(memberIds: string[], options: RepositoryTransactionOptions = {}): Promise<Map<string, Gift>> {
-        const map = new Map<string, Gift>();
-
-        if (memberIds.length === 0) {
-            return map;
-        }
-
-        const idList = memberIds.map(id => `'${id}'`).join(',');
-        const collection = await this.model.findAll({
-            filter: `redeemer_member_id:[${idList}]+status:redeemed`,
-            ...options
-        });
-
-        for (const model of collection.models) {
-            const gift = this.toGift(model);
-            if (gift.redeemerMemberId) {
-                map.set(gift.redeemerMemberId, gift);
-            }
-        }
-
-        return map;
-    }
-
-    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();
-
-        const collection = await this.model.findAll({
-            filter: `status:redeemed+consumes_at:<'${now.toISOString()}'`
-        });
-
-        return collection.models.map(model => this.toGift(model));
-    }
-
-    async findPendingExpiration(): Promise<Gift[]> {
-        const now = new Date();
-
-        const collection = await this.model.findAll({
-            filter: `status:purchased+expires_at:<'${now.toISOString()}'`
-        });
-
-        return collection.models.map(model => this.toGift(model));
-    }
-
-    async findPendingReminder({now, reminderLeadMs, reminderFloorMs, transacting}: FindPendingReminderOptions): Promise<Gift[]> {
-        const upper = new Date(now.getTime() + reminderLeadMs).toISOString();
-        const lower = new Date(now.getTime() + reminderFloorMs).toISOString();
-
-        const collection = await this.model.findAll({
-            filter: `status:redeemed+consumes_at:<='${upper}'+consumes_at:>'${lower}'+consumes_soon_reminder_sent_at:null`,
-            transacting
-        });
-
-        return collection.models.map(model => this.toGift(model));
-    }
-
-    async findUnsentReminders(): Promise<Gift[]> {
-        const now = new Date().toISOString();
-
-        const collection = await this.model.findAll({
-            filter: `status:redeemed+consumes_at:>'${now}'+consumes_soon_reminder_sent_at:null`
-        });
-
-        return collection.models.map(model => this.toGift(model));
-    }
-
-    async create(gift: Gift, options: RepositoryTransactionOptions = {}) {
-        await this.model.add(this.toRow(gift), options);
-    }
-
-    async update(gift: Gift, options: RepositoryTransactionOptions = {}) {
-        const existing = await this.model.findOne({
-            token: gift.token
-        }, {require: false, ...options});
-
-        if (!existing) {
-            throw new errors.InternalServerError({message: `Gift not found: ${gift.token}`});
-        }
-
-        await existing.save(this.toRow(gift), {
-            autoRefresh: false,
-            method: 'update',
-            patch: true,
-            ...options
-        });
-    }
-
-    async transaction<T>(callback: (transacting: Knex.Transaction) => Promise<T>): Promise<T> {
-        return await this.model.transaction(callback);
-    }
-
-    private toRow(gift: Gift): GiftRow {
-        return encodeGift(gift);
-    }
-
-    private toGift(model: BookshelfDocument<GiftRow>): Gift {
-        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-offer.ts

@@ -1,127 +0,0 @@
-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.ts

@@ -1,62 +0,0 @@
-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.ts

@@ -1,51 +0,0 @@
-import errors from '@tryghost/errors';
-import {GiftService} from './gift-service';
-
-type Frame = {
-    data: {
-        token: string;
-    };
-    options?: {
-        context?: {
-            member?: {
-                id: string;
-                status: string;
-            } | null;
-        };
-    };
-};
-
-export class GiftController {
-    private readonly service: GiftService;
-
-    constructor({
-        service
-    }: {
-        service: GiftService;
-    }) {
-        this.service = service;
-    }
-
-    async getRedeemable(frame: Frame) {
-        const token = frame.data.token;
-        const memberStatus = frame.options?.context?.member?.status ?? null;
-
-        return this.service.getRedeemable({token, memberStatus});
-    }
-
-    async redeem(frame: Frame) {
-        const token = frame.data.token;
-        const member = frame.options?.context?.member;
-
-        if (!member?.id) {
-            throw new errors.UnauthorizedError({
-                message: 'Member authentication required.'
-            });
-        }
-
-        return this.service.redeem({
-            token,
-            memberId: member.id
-        });
-    }
-}

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

@@ -1,97 +0,0 @@
-import {promises as fs} from 'node:fs';
-import path from 'node:path';
-import Handlebars from 'handlebars';
-import type {GiftPurchaseConfirmationData} from './email-templates/gift-purchase-confirmation';
-import {renderText as renderPurchaseConfirmationText} from './email-templates/gift-purchase-confirmation';
-import type {GiftReminderData} from './email-templates/gift-reminder';
-import {renderText as renderReminderText} from './email-templates/gift-reminder';
-
-export type Translate = (key: string, options?: Record<string, unknown>) => string;
-
-export class GiftEmailRenderer {
-    private readonly handlebars: typeof Handlebars;
-    private readonly t: Translate;
-
-    private purchaseConfirmationTemplate: HandlebarsTemplateDelegate | null = null;
-    private reminderTemplate: HandlebarsTemplateDelegate | null = null;
-
-    constructor({t}: {t: Translate}) {
-        this.t = t;
-        this.handlebars = Handlebars.create();
-        this.registerTemplateHelpers();
-    }
-
-    async renderPurchaseConfirmation(data: GiftPurchaseConfirmationData): Promise<{html: string; text: string}> {
-        if (!this.purchaseConfirmationTemplate) {
-            const source = await fs.readFile(path.join(__dirname, './email-templates/gift-purchase-confirmation.hbs'), 'utf8');
-
-            this.purchaseConfirmationTemplate = this.handlebars.compile(source);
-        }
-
-        return {
-            html: this.purchaseConfirmationTemplate(data),
-            text: renderPurchaseConfirmationText(data, this.t)
-        };
-    }
-
-    async renderReminder(data: GiftReminderData): Promise<{html: string; text: string}> {
-        if (!this.reminderTemplate) {
-            const source = await fs.readFile(path.join(__dirname, './email-templates/gift-reminder.hbs'), 'utf8');
-
-            this.reminderTemplate = this.handlebars.compile(source);
-        }
-
-        return {
-            html: this.reminderTemplate(data),
-            text: renderReminderText(data, this.t)
-        };
-    }
-
-    private registerTemplateHelpers(): void {
-        this.handlebars.registerHelper('t', (key: string, options?: Handlebars.HelperOptions) => {
-            const hash = options?.hash || {};
-            const escapedHash = Object.entries(hash).reduce<Record<string, string>>((acc, [name, value]) => {
-                acc[name] = this.htmlSafeInterpolationValue(value);
-                return acc;
-            }, {});
-
-            return new Handlebars.SafeString(this.t(key, {
-                ...escapedHash,
-                interpolation: {escapeValue: false}
-            }));
-        });
-
-        this.handlebars.registerHelper('strong', (value: unknown) => {
-            return new Handlebars.SafeString(`<strong>${this.escape(value)}</strong>`);
-        });
-
-        this.handlebars.registerHelper('linkTag', (href: unknown, text: unknown, options?: Handlebars.HelperOptions) => {
-            const className = options?.hash?.class ? ` class="${this.escape(options.hash.class)}"` : '';
-            const style = options?.hash?.style ? ` style="${this.escape(options.hash.style)}"` : '';
-
-            return new Handlebars.SafeString(`<a${className} href="${this.escape(href)}"${style}>${this.escape(text)}</a>`);
-        });
-
-        this.handlebars.registerHelper('mailto', (email: unknown) => `mailto:${email}`);
-    }
-
-    private htmlSafeInterpolationValue(value: unknown): string {
-        if (this.isSafeString(value)) {
-            return value.toHTML();
-        }
-
-        return this.escape(value);
-    }
-
-    private isSafeString(value: unknown): value is {toHTML(): string} {
-        return Boolean(value && typeof value === 'object' && typeof (value as {toHTML?: unknown}).toHTML === 'function');
-    }
-
-    private escape(value: unknown): string {
-        if (this.isSafeString(value)) {
-            return value.toHTML();
-        }
-
-        return Handlebars.Utils.escapeExpression(String(value ?? ''));
-    }
-}