ghost 5.110.4 → 5.112.0

package/core/server/services/members-events/LastSeenAtUpdater.js

@@ -0,0 +1,192 @@
+const {MemberPageViewEvent, MemberCommentEvent, MemberLinkClickEvent} = require('@tryghost/member-events');
+const moment = require('moment-timezone');
+const {IncorrectUsageError} = require('@tryghost/errors');
+const {EmailOpenedEvent} = require('@tryghost/email-events');
+const logging = require('@tryghost/logging');
+const LastSeenAtCache = require('./LastSeenAtCache');
+
+/**
+ * Listen for `MemberViewEvent` to update the `member.last_seen_at` timestamp
+ */
+class LastSeenAtUpdater {
+    /**
+     * Initializes the event subscriber
+     * @param {Object} deps dependencies
+     * @param {Object} deps.services The list of service dependencies
+     * @param {any} deps.services.settingsCache The settings service
+     * @param {() => object} deps.getMembersApi - A function which returns an instance of members-api
+     * @param {any} deps.db Database connection
+     * @param {any} deps.events The event emitter
+     * @param {any} deps.lastSeenAtCache An instance of the last seen at cache
+     * @param {any} deps.config Ghost config for click tracking
+     */
+    constructor({
+        services: {
+            settingsCache
+        },
+        getMembersApi,
+        db,
+        events,
+        lastSeenAtCache,
+        config
+    }) {
+        if (!getMembersApi) {
+            throw new IncorrectUsageError({message: 'Missing option getMembersApi'});
+        }
+
+        this._getMembersApi = getMembersApi;
+        this._settingsCacheService = settingsCache;
+        this._db = db;
+        this._events = events;
+        this._lastSeenAtCache = lastSeenAtCache || new LastSeenAtCache({services: {settingsCache}});
+        this._config = config;
+    }
+    /**
+     * Subscribe to events of this domainEvents service
+     * @param {any} domainEvents The DomainEvents service
+     */
+    subscribe(domainEvents) {
+        domainEvents.subscribe(MemberPageViewEvent, async (event) => {
+            try {
+                await this.cachedUpdateLastSeenAt(event.data.memberId, event.data.memberLastSeenAt, event.timestamp);
+            } catch (err) {
+                logging.error(`Error in LastSeenAtUpdater.MemberPageViewEvent listener for member ${event.data.memberId}`);
+                logging.error(err);
+            }
+        });
+
+        // Only disable if explicitly set to false in config
+        const shouldUpdateForClickTracking = !this._config || this._config.get('backgroundJobs:clickTrackingLastSeenAtUpdater') !== false;
+        if (shouldUpdateForClickTracking) {
+            domainEvents.subscribe(MemberLinkClickEvent, async (event) => {
+                try {
+                    await this.cachedUpdateLastSeenAt(event.data.memberId, event.data.memberLastSeenAt, event.timestamp);
+                } catch (err) {
+                    logging.error(`Error in LastSeenAtUpdater.MemberLinkClickEvent listener for member ${event.data.memberId}`);
+                    logging.error(err);
+                }
+            });
+        }
+
+        domainEvents.subscribe(MemberCommentEvent, async (event) => {
+            try {
+                await this.updateLastCommentedAt(event.data.memberId, event.timestamp);
+            } catch (err) {
+                logging.error(`Error in LastSeenAtUpdater.MemberCommentEvent listener for member ${event.data.memberId}`);
+                logging.error(err);
+            }
+        });
+
+        domainEvents.subscribe(EmailOpenedEvent, async (event) => {
+            try {
+                await this.updateLastSeenAtWithoutKnownLastSeen(event.memberId, event.timestamp);
+            } catch (err) {
+                logging.error(`Error in LastSeenAtUpdater.EmailOpenedEvent listener for member ${event.memberId}, emailRecipientId ${event.emailRecipientId}`);
+                logging.error(err);
+            }
+        });
+    }
+
+    /**
+     * Updates the member.last_seen_at field if it wasn't updated in the current day yet (in the publication timezone)
+     * Example: current time is 2022-02-28 18:00:00
+     * - memberLastSeenAt is 2022-02-27 23:00:00, timestamp is current time, then `last_seen_at` is set to the current time
+     * - memberLastSeenAt is 2022-02-28 01:00:00, timestamp is current time, then `last_seen_at` isn't changed
+     * @param {string} memberId The id of the member to be udpated
+     * @param {Date} timestamp The event timestamp
+     */
+    async updateLastSeenAtWithoutKnownLastSeen(memberId, timestamp) {
+        // Note: we are not using Bookshelf / member repository to prevent firing webhooks + to prevent deadlock issues
+        // If we would use the member repostiory, we would create a forUpdate lock when editing the member, including when fetching the member labels. Creating a possible deadlock if somewhere else we do the reverse in a transaction.
+        const timezone = this._settingsCacheService.get('timezone') || 'Etc/UTC';
+        const startOfDayInSiteTimezone = moment.utc(timestamp).tz(timezone).startOf('day').utc().format('YYYY-MM-DD HH:mm:ss');
+        const formattedTimestamp = moment.utc(timestamp).format('YYYY-MM-DD HH:mm:ss');
+        await this._db.knex('members')
+            .where('id', '=', memberId)
+            .andWhere(builder => builder
+                .where('last_seen_at', '<', startOfDayInSiteTimezone)
+                .orWhereNull('last_seen_at')
+            )
+            .update({
+                last_seen_at: formattedTimestamp
+            });
+    }
+
+    /**
+     * Updates the member.last_seen_at field if it wasn't updated in the current day yet (in the publication timezone)
+     */
+    async cachedUpdateLastSeenAt(memberId, memberLastSeenAt, timestamp) {
+        if (this._lastSeenAtCache.shouldUpdateMember(memberId)) {
+            await this.updateLastSeenAt(memberId, memberLastSeenAt, timestamp);
+        }
+    }
+
+    /**
+     * Updates the member.last_seen_at field if it wasn't updated in the current day yet (in the publication timezone)
+     * Example: current time is 2022-02-28 18:00:00
+     * - memberLastSeenAt is 2022-02-27 23:00:00, timestamp is current time, then `last_seen_at` is set to the current time
+     * - memberLastSeenAt is 2022-02-28 01:00:00, timestamp is current time, then `last_seen_at` isn't changed
+     * @param {string} memberId The id of the member to be udpated
+     * @param {Date} timestamp The event timestamp
+     */
+    async updateLastSeenAt(memberId, memberLastSeenAt, timestamp) {
+        const timezone = this._settingsCacheService.get('timezone');
+        // First, check if memberLastSeenAt is null or before the beginning of the current day in the publication timezone
+        // This isn't strictly necessary since we will fetch the member row for update and double check this
+        // This is an optimization to avoid unnecessary database queries if last_seen_at is already after the beginning of the current day
+        if (memberLastSeenAt === null || moment(moment.utc(timestamp).tz(timezone).startOf('day')).isAfter(memberLastSeenAt)) {
+            try {
+                // Pre-emptively update local cache so we don't update the same member again in the same day
+                this._lastSeenAtCache.add(memberId);
+                const membersApi = this._getMembersApi();
+                await this._db.knex.transaction(async (trx) => {
+                    // To avoid a race condition, we lock the member row for update, then the last_seen_at field again to prevent simultaneous updates
+                    const currentMember = await membersApi.members.get({id: memberId}, {require: true, transacting: trx, forUpdate: true});
+                    const currentMemberLastSeenAt = currentMember.get('last_seen_at');
+                    if (currentMemberLastSeenAt === null || moment(moment.utc(timestamp).tz(timezone).startOf('day')).isAfter(currentMemberLastSeenAt)) {
+                        const memberToUpdate = await currentMember.refresh({transacting: trx, forUpdate: false, withRelated: ['labels', 'newsletters']});
+                        const updatedMember = await memberToUpdate.save({last_seen_at: moment.utc(timestamp).format('YYYY-MM-DD HH:mm:ss')}, {transacting: trx, patch: true, method: 'update'});
+                        // The standard event doesn't get emitted inside the transaction, so we do it manually
+                        this._events.emit('member.edited', updatedMember);
+                        return Promise.resolve(updatedMember);
+                    }
+                    return Promise.resolve(undefined);
+                });
+            } catch (err) {
+                // Remove the member from the cache if an error occurs
+                // This is to ensure that the member is updated on the next event if this one fails
+                this._lastSeenAtCache.remove(memberId);
+                // Bubble up the error to the event listener
+                throw err;
+            }
+        }
+    }
+
+    /**
+     * Updates the member.last_seen_at field if it wasn't updated in the current day yet (in the publication timezone)
+     * Example: current time is 2022-02-28 18:00:00
+     * - memberLastSeenAt is 2022-02-27 23:00:00, timestamp is current time, then `last_seen_at` is set to the current time
+     * - memberLastSeenAt is 2022-02-28 01:00:00, timestamp is current time, then `last_seen_at` isn't changed
+     * @param {string} memberId The id of the member to be udpated
+     * @param {Date} timestamp The event timestamp
+     */
+    async updateLastCommentedAt(memberId, timestamp) {
+        const membersApi = this._getMembersApi();
+        const member = await membersApi.members.get({id: memberId}, {require: true});
+        const timezone = this._settingsCacheService.get('timezone');
+
+        const memberLastSeenAt = member.get('last_seen_at');
+        const memberLastCommentedAt = member.get('last_commented_at');
+
+        if (memberLastSeenAt === null || moment(moment.utc(timestamp).tz(timezone).startOf('day')).isAfter(memberLastSeenAt) || memberLastCommentedAt === null || moment(moment.utc(timestamp).tz(timezone).startOf('day')).isAfter(memberLastCommentedAt)) {
+            await membersApi.members.update({
+                last_seen_at: moment.utc(timestamp).format('YYYY-MM-DD HH:mm:ss'),
+                last_commented_at: moment.utc(timestamp).format('YYYY-MM-DD HH:mm:ss')
+            }, {
+                id: memberId
+            });
+        }
+    }
+}
+
+module.exports = LastSeenAtUpdater;

package/core/server/services/members-events/index.js

@@ -13,7 +13,9 @@ class MembersEventsServiceWrapper {
         }
 
         // Wire up all the dependencies
-        const {EventStorage, LastSeenAtUpdater, LastSeenAtCache} = require('@tryghost/members-events-service');
+        const EventStorage = require('./EventStorage');
+        const LastSeenAtUpdater = require('./LastSeenAtUpdater');
+        const LastSeenAtCache = require('./LastSeenAtCache');
         const models = require('../../models');
 
         // Listen for events and store them in the database

package/core/server/services/mentions-email-report/MentionEmailReportJob.js

@@ -0,0 +1,117 @@
+module.exports = class MentionEmailReportJob {
+    /** @type {IMentionReportGenerator} */
+    #mentionReportGenerator;
+
+    /** @type {IMentionReportRecipientRepository} */
+    #mentionReportRecipientRepository;
+
+    /** @type {IMentionReportEmailView} */
+    #mentionReportEmailView;
+
+    /** @type {IMentionReportHistoryService} */
+    #mentionReportHistoryService;
+
+    /** @type {IEmailService} */
+    #emailService;
+
+    /**
+     * @param {object} deps
+     * @param {IMentionReportGenerator} deps.mentionReportGenerator
+     * @param {IMentionReportRecipientRepository} deps.mentionReportRecipientRepository
+     * @param {IMentionReportEmailView} deps.mentionReportEmailView
+     * @param {IMentionReportHistoryService} deps.mentionReportHistoryService
+     * @param {IEmailService} deps.emailService
+     */
+    constructor(deps) {
+        this.#mentionReportGenerator = deps.mentionReportGenerator;
+        this.#mentionReportRecipientRepository = deps.mentionReportRecipientRepository;
+        this.#mentionReportEmailView = deps.mentionReportEmailView;
+        this.#mentionReportHistoryService = deps.mentionReportHistoryService;
+        this.#emailService = deps.emailService;
+    }
+
+    /**
+     * Checks for new mentions since the last report and sends an email to the recipients.
+     *
+     * @returns {Promise<number>} - A promise that resolves with the number of mentions found.
+     */
+    async sendLatestReport() {
+        const lastReport = await this.#mentionReportHistoryService.getLatestReportDate();
+        const now = new Date();
+
+        if (now.valueOf() - lastReport.valueOf() < 24 * 60 * 60 * 1000) {
+            return 0;
+        }
+
+        const report = await this.#mentionReportGenerator.getMentionReport(lastReport, now);
+
+        report.mentions = report.mentions.map((mention) => {
+            return {
+                targetUrl: mention.target,
+                sourceUrl: mention.source,
+                sourceTitle: mention.sourceTitle,
+                sourceExcerpt: mention.sourceExcerpt,
+                sourceSiteTitle: mention.sourceSiteTitle,
+                sourceFavicon: mention.sourceFavicon,
+                sourceAuthor: mention.sourceAuthor,
+                sourceFeaturedImage: mention.sourceFeaturedImage
+            };
+        });
+
+        if (!report?.mentions?.length) {
+            return 0;
+        }
+
+        const recipients = await this.#mentionReportRecipientRepository.getMentionReportRecipients();
+
+        for (const recipient of recipients) {
+            const subject = await this.#mentionReportEmailView.renderSubject(report, recipient);
+            const html = await this.#mentionReportEmailView.renderHTML(report, recipient);
+            const text = await this.#mentionReportEmailView.renderText(report, recipient);
+
+            await this.#emailService.send(recipient.email, subject, html, text);
+        }
+
+        await this.#mentionReportHistoryService.setLatestReportDate(now);
+
+        return report.mentions.length;
+    }
+};
+
+/**
+ * @typedef {object} MentionReportRecipient
+ * @prop {string} email
+ * @prop {string} slug
+ */
+
+/**
+ * @typedef {object} IMentionReportRecipientRepository
+ * @prop {() => Promise<MentionReportRecipient[]>} getMentionReportRecipients
+ */
+
+/**
+ * @typedef {import('@tryghost/webmentions/lib/MentionsAPI').MentionReport} MentionReport
+ */
+
+/**
+ * @typedef {object} IMentionReportGenerator
+ * @prop {(startDate: Date, endDate: Date) => Promise<MentionReport>} getMentionReport
+ */
+
+/**
+ * @typedef {object} IMentionReportEmailView
+ * @prop {(report: MentionReport, recipient: MentionReportRecipient) => Promise<string>} renderHTML
+ * @prop {(report: MentionReport, recipient: MentionReportRecipient) => Promise<string>} renderText
+ * @prop {(report: MentionReport, recipient: MentionReportRecipient) => Promise<string>} renderSubject
+ */
+
+/**
+ * @typedef {object} IEmailService
+ * @prop {(to: string, subject: string, html: string, text: string) => Promise<void>} send
+ */
+
+/**
+ * @typedef {object} IMentionReportHistoryService
+ * @prop {() => Promise<Date>} getLatestReportDate
+ * @prop {(date: Date) => Promise<void>} setLatestReportDate
+ */

package/core/server/services/mentions-email-report/service.js

@@ -1,8 +1,8 @@
-const MentionEmailReportJob = require('@tryghost/mentions-email-report');
+const MentionEmailReportJob = require('./MentionEmailReportJob');
 
 /**
- * @typedef {import('@tryghost/mentions-email-report/lib/mentions-email-report').MentionReport} MentionReport
- * @typedef {import('@tryghost/mentions-email-report/lib/mentions-email-report').MentionReportRecipient} MentionReportRecipient
+ * @typedef {MentionEmailReportJob.MentionReport} MentionReport
+ * @typedef {MentionEmailReportJob.MentionReportRecipient} MentionReportRecipient
  */
 
 let initialised = false;

package/core/server/services/staff/StaffService.js

@@ -0,0 +1,179 @@
+const {MemberCreatedEvent, SubscriptionCancelledEvent, SubscriptionActivatedEvent} = require('@tryghost/member-events');
+const {MilestoneCreatedEvent} = require('@tryghost/milestones');
+
+// @NOTE: 'StaffService' is a vague name that does not describe what it's actually doing.
+//         Possibly, "StaffNotificationService" or "StaffEventNotificationService" would be a more accurate name
+class StaffService {
+    constructor({logging, models, mailer, settingsCache, settingsHelpers, urlUtils, blogIcon, DomainEvents, labs, memberAttributionService}) {
+        this.logging = logging;
+        this.labs = labs;
+        /** @private */
+        this.settingsCache = settingsCache;
+        this.models = models;
+        this.DomainEvents = DomainEvents;
+        this.memberAttributionService = memberAttributionService;
+
+        const Emails = require('./StaffServiceEmails');
+
+        this.emails = new Emails({
+            logging,
+            models,
+            mailer,
+            settingsHelpers,
+            settingsCache,
+            urlUtils,
+            blogIcon,
+            labs
+        });
+    }
+
+    /** @private */
+    getSerializedData({member, tier = null, subscription = null, offer = null}) {
+        return {
+            offer: offer ? {
+                name: offer.name,
+                type: offer.discount_type,
+                currency: offer.currency,
+                duration: offer.duration,
+                durationInMonths: offer.duration_in_months,
+                amount: offer.discount_amount
+            } : null,
+            subscription: subscription ? {
+                id: subscription.id,
+                amount: subscription.plan?.amount,
+                interval: subscription.plan?.interval,
+                currency: subscription.plan?.currency,
+                startDate: subscription.start_date,
+                cancelAt: subscription.current_period_end,
+                cancellationReason: subscription.cancellation_reason
+            } : null,
+            member: member ? {
+                id: member.id,
+                name: member.name,
+                email: member.email,
+                geolocation: member.geolocation,
+                status: member.status,
+                created_at: member.created_at
+            } : null,
+            tier: tier ? {
+                id: tier.id,
+                name: tier.name
+            } : null
+        };
+    }
+
+    /** @private */
+    async getDataFromIds({memberId, tierId = null, subscriptionId = null, offerId = null}) {
+        const memberModel = memberId ? await this.models.Member.findOne({id: memberId}) : null;
+        const tierModel = tierId ? await this.models.Product.findOne({id: tierId}) : null;
+        const subscriptionModel = subscriptionId ? await this.models.StripeCustomerSubscription.findOne({id: subscriptionId}) : null;
+        const offerModel = offerId ? await this.models.Offer.findOne({id: offerId}) : null;
+
+        return this.getSerializedData({
+            member: memberModel?.toJSON(),
+            tier: tierModel?.toJSON(),
+            subscription: subscriptionModel?.toJSON(),
+            offer: offerModel?.toJSON()
+        });
+    }
+
+    /** @private */
+    async handleEvent(type, event) {
+        if (type === MilestoneCreatedEvent && event.data.milestone) {
+            await this.emails.notifyMilestoneReceived(event.data);
+        }
+
+        if (!['api', 'member'].includes(event.data.source)) {
+            return;
+        }
+
+        const {member, tier, subscription, offer} = await this.getDataFromIds({
+            memberId: event.data.memberId,
+            tierId: event.data.tierId,
+            subscriptionId: event.data.subscriptionId,
+            offerId: event.data.offerId
+        });
+
+        if (type === MemberCreatedEvent && member.status === 'free') {
+            let attribution;
+            if (event.data?.attribution) {
+                attribution = await this.memberAttributionService.fetchResource(event.data.attribution);
+            } else {
+                try {
+                    attribution = await this.memberAttributionService.getMemberCreatedAttribution(event.data.memberId);
+                } catch (e) {
+                    this.logging.warn(`Failed to get attribution for member - ${event?.data?.memberId}`);
+                }
+            }
+            await this.emails.notifyFreeMemberSignup({
+                member,
+                attribution
+            });
+        } else if (type === SubscriptionActivatedEvent) {
+            let attribution;
+            if (event.data?.attribution) {
+                attribution = await this.memberAttributionService.fetchResource(event.data.attribution);
+            } else {
+                try {
+                    attribution = await this.memberAttributionService.getSubscriptionCreatedAttribution(event.data.subscriptionId);
+                } catch (e) {
+                    this.logging.warn(`Failed to get attribution for member - ${event?.data?.memberId}`);
+                }
+            }
+            await this.emails.notifyPaidSubscriptionStarted({
+                member,
+                offer,
+                tier,
+                subscription,
+                attribution
+            });
+        } else if (type === SubscriptionCancelledEvent) {
+            await this.emails.notifyPaidSubscriptionCanceled({
+                member,
+                tier,
+                subscription,
+                ...event.data
+            });
+        }
+    }
+
+    subscribeEvents() {
+        // Trigger email for free member signup
+        this.DomainEvents.subscribe(MemberCreatedEvent, async (event) => {
+            try {
+                await this.handleEvent(MemberCreatedEvent, event);
+            } catch (e) {
+                this.logging.error(e, `Failed to notify free member signup - ${event?.data?.memberId}`);
+            }
+        });
+
+        // Trigger email on paid subscription start
+        this.DomainEvents.subscribe(SubscriptionActivatedEvent, async (event) => {
+            try {
+                await this.handleEvent(SubscriptionActivatedEvent, event);
+            } catch (e) {
+                this.logging.error(e, `Failed to notify paid member subscription start - ${event?.data?.memberId}`);
+            }
+        });
+
+        // Trigger email when a member cancels their subscription
+        this.DomainEvents.subscribe(SubscriptionCancelledEvent, async (event) => {
+            try {
+                await this.handleEvent(SubscriptionCancelledEvent, event);
+            } catch (e) {
+                this.logging.error(e, `Failed to notify paid member subscription cancel - ${event?.data?.memberId}`);
+            }
+        });
+
+        // Trigger email when a new milestone is reached
+        this.DomainEvents.subscribe(MilestoneCreatedEvent, async (event) => {
+            try {
+                await this.handleEvent(MilestoneCreatedEvent, event);
+            } catch (e) {
+                this.logging.error(e, `Failed to notify milestone`);
+            }
+        });
+    }
+}
+
+module.exports = StaffService;