ghost 6.57.1 → 6.58.0

package/core/server/services/README.md

@@ -0,0 +1,30 @@
+# Ghost Core services
+
+Services under this directory own domain and integration logic used by Ghost
+Core. Follow an existing service in the same area when extending established
+code. New standalone service logic should be TypeScript unless it must extend an
+existing JavaScript module.
+
+The gifts, donations, and related services show the current transition pattern:
+domain logic uses TypeScript with named exports, while a thin CommonJS
+`index.js` or wrapper remains only where boot code or an existing `require()`
+boundary needs it.
+
+## Initialization
+
+Ghost's boot sequence owns service construction. A new service that requires
+initialization must expose an explicit `init()` and be called from
+`ghost/core/core/boot.js` in the appropriate boot phase. Do not make the first
+request responsible for constructing the service.
+
+Keep wrapper initialization idempotent when callers may safely reach it more
+than once. Add shutdown or cleanup handling to the boot lifecycle when the
+service owns resources that must be released.
+
+## Related guidance
+
+- [Monorepo structure](../../../../../docs/codebase/monorepo-structure.md)
+- [Configuration](../../../../../docs/codebase/configuration.md)
+- [Database migrations](../../../../../docs/practices/database-migrations.md)
+- [API design](../../../../../docs/practices/api-design.md)
+- [Error handling](../../../../../docs/practices/error-handling.md)

package/core/server/services/activitypub/activity-pub-service.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActivityPubService = void 0;
 const bson_objectid_1 = __importDefault(require("bson-objectid"));
-const node_fetch_1 = __importDefault(require("node-fetch"));
 class ActivityPubService {
     knex;
     siteUrl;
@@ -69,7 +68,7 @@ class ActivityPubService {
     async getWebhookSecret() {
         try {
             const token = await this.getOwnerUserToken();
-            const res = await (0, node_fetch_1.default)(new URL('.ghost/activitypub/v1/site/', this.siteUrl), {
+            const res = await fetch(new URL('.ghost/activitypub/v1/site/', this.siteUrl), {
                 headers: {
                     Authorization: `Bearer ${token}`
                 }
@@ -151,7 +150,7 @@ class ActivityPubService {
     async disableSite() {
         try {
             const token = await this.getOwnerUserToken();
-            await (0, node_fetch_1.default)(new URL('.ghost/activitypub/v1/site/', this.siteUrl), {
+            await fetch(new URL('.ghost/activitypub/v1/site/', this.siteUrl), {
                 method: 'DELETE',
                 headers: {
                     Authorization: `Bearer ${token}`

package/core/server/services/adapter-manager/base-classes.js

@@ -7,6 +7,7 @@ const adapter_base_sso_1 = require("@tryghost/adapter-base-sso");
 const adapter_base_cache_1 = require("@tryghost/adapter-base-cache");
 const adapter_base_redirects_1 = require("@tryghost/adapter-base-redirects");
 const adapter_base_route_settings_1 = require("@tryghost/adapter-base-route-settings");
+const adapter_base_jobs_1 = require("@tryghost/adapter-base-jobs");
 /**
  * The base class every adapter of a given type must extend. Also read by
  * bin/validate-adapters.js, which checks adapter implementations at build time -
@@ -18,5 +19,6 @@ exports.baseClasses = {
     sso: adapter_base_sso_1.SSOBase,
     cache: adapter_base_cache_1.CacheBase,
     redirects: adapter_base_redirects_1.RedirectsStoreBase,
-    'route-settings': adapter_base_route_settings_1.RouteSettingsStoreBase
+    'route-settings': adapter_base_route_settings_1.RouteSettingsStoreBase,
+    jobs: adapter_base_jobs_1.JobsBackendBase
 };

package/core/server/services/auth/passwordreset.js

@@ -5,6 +5,7 @@ const tpl = require('@tryghost/tpl');
 const moment = require('moment');
 
 const models = require('../../models');
+const ghostBookshelf = require('../../models/base');
 const urlUtils = require('../../../shared/url-utils').default;
 const mail = require('../mail');
 
@@ -77,67 +78,62 @@ function extractTokenParts(options) {
 }
 
 function doReset(options, tokenParts, settingsAPI) {
-    let dbHash;
-
     const data = options.data.password_reset[0];
     const resetToken = data.token;
     const oldPassword = data.oldPassword;
     const newPassword = data.newPassword;
 
-    return settingsAPI.read(_.merge({key: 'db_hash'}, _.omit(options, 'data')))
-        .then((response) => {
-            dbHash = response.settings[0].value;
+    return ghostBookshelf.transaction(async (transacting) => {
+        const txOptions = {context: options.context, transacting};
 
-            return models.User.getByEmail(tokenParts.email, options);
-        })
-        .then((user) => {
-            if (!user) {
-                throw new errors.NotFoundError({message: tpl(messages.userNotFound)});
-            }
+        const settingsResponse = await settingsAPI.read({key: 'db_hash', ...txOptions});
+        const dbHash = settingsResponse.settings[0].value;
 
-            let compareResult = security.tokens.resetToken.compare({
-                token: resetToken,
-                dbHash: dbHash,
-                password: user.get('password')
-            });
+        const candidate = await models.User.getByEmail(tokenParts.email, txOptions);
+        if (!candidate) {
+            throw new errors.NotFoundError({message: tpl(messages.userNotFound)});
+        }
 
-            if (!compareResult.correct) {
-                let error;
-                if (compareResult.reason === 'expired' || compareResult.reason === 'invalid_expiry') {
-                    error = new errors.BadRequestError({
-                        message: tpl(messages.expired.message),
-                        context: tpl(messages.expired.context),
-                        help: tpl(messages.expired.help)
-                    });
-                } else {
-                    error = new errors.BadRequestError({
-                        message: tpl(messages.invalidToken.message),
-                        context: tpl(messages.invalidToken.context),
-                        help: tpl(messages.invalidToken.help)
-                    });
-                }
-
-                return Promise.reject(error);
-            }
+        const user = await new models.User({id: candidate.id})
+            .fetch({...txOptions, forUpdate: true, require: true});
 
-            return models.User.changePassword({
-                oldPassword: oldPassword,
-                newPassword: newPassword,
-                user_id: user.id
-            }, options);
-        })
-        .then((updatedUser) => {
-            updatedUser.set('status', 'active');
-            return updatedUser.save(options);
-        }).then((savedUser) => {
-            return {user: savedUser};
-        })
-        .catch((err) => {
-            if (errors.utils.isGhostError(err)) {
-                return Promise.reject(err);
-            }
-            return Promise.reject(new errors.UnauthorizedError({err: err}));
+        let compareResult = security.tokens.resetToken.compare({
+            token: resetToken,
+            dbHash: dbHash,
+            password: user.get('password')
         });
+
+        if (!compareResult.correct) {
+            if (compareResult.reason === 'expired' || compareResult.reason === 'invalid_expiry') {
+                throw new errors.BadRequestError({
+                    message: tpl(messages.expired.message),
+                    context: tpl(messages.expired.context),
+                    help: tpl(messages.expired.help)
+                });
+            } else {
+                throw new errors.BadRequestError({
+                    message: tpl(messages.invalidToken.message),
+                    context: tpl(messages.invalidToken.context),
+                    help: tpl(messages.invalidToken.help)
+                });
+            }
+        }
+
+        const updatedUser = await models.User.changePassword({
+            oldPassword: oldPassword,
+            newPassword: newPassword,
+            user_id: user.id
+        }, txOptions);
+
+        updatedUser.set('status', 'active');
+        const savedUser = await updatedUser.save(null, txOptions);
+        return {user: savedUser};
+    }).catch((err) => {
+        if (errors.utils.isGhostError(err)) {
+            return Promise.reject(err);
+        }
+        return Promise.reject(new errors.UnauthorizedError({err: err}));
+    });
 }
 
 async function sendResetNotification(data, mailAPI) {

package/core/server/services/automations/database-automations-repository.js

@@ -37,7 +37,7 @@ function createDatabaseAutomationsRepository({ knex, fakeWaitHoursMultiplier })
                 await ensureDefaultAutomations(trx);
                 const rows = await loadAutomations(trx);
                 return {
-                    data: rows.map(row => buildAutomationSummary(row)),
+                    data: rows.map(row => buildAutomationBrowseResult(row)),
                     meta: {
                         pagination: buildPagination(rows.length)
                     }
@@ -697,9 +697,16 @@ async function loadAutomationBySlug(trx, slug) {
     return row ?? null;
 }
 async function loadAutomations(trx) {
+    const runStats = trx('automation_runs')
+        .select('automation_id')
+        .max({ last_run_created_at: 'created_at' })
+        .count({ total_run_count: '*' })
+        .groupBy('automation_id')
+        .as('run_stats');
     return await trx('automations')
-        .select('id', 'slug', 'name', 'status', 'created_at', 'updated_at')
-        .orderBy('name');
+        .select('automations.id', 'automations.slug', 'automations.name', 'automations.status', 'automations.created_at', 'automations.updated_at', 'run_stats.last_run_created_at', 'run_stats.total_run_count')
+        .leftJoin(runStats, 'automations.id', 'run_stats.automation_id')
+        .orderBy('automations.name');
 }
 async function updateAutomation(trx, automation) {
     await trx('automations')
@@ -978,6 +985,15 @@ function buildAutomationSummary(automation) {
         updated_at: serializeDate(automation.updated_at)
     };
 }
+function buildAutomationBrowseResult(automation) {
+    return {
+        ...buildAutomationSummary(automation),
+        stats: {
+            last_run_created_at: automation.last_run_created_at ? (0, database_date_1.fromDatabaseDate)(automation.last_run_created_at) : null,
+            total_run_count: Number(automation.total_run_count ?? 0)
+        }
+    };
+}
 function serializeDate(date) {
     const normalizedDate = (0, database_date_1.fromDatabaseDate)(date);
     normalizedDate.setMilliseconds(0);

package/core/server/services/automations/poll.js

@@ -103,14 +103,8 @@ const processStep = async ({ automationsApi, memberWelcomeEmailService, schedule
                 break;
             case 'send_email': {
                 if (!hasUpdatesAndAnnouncementsEnabled(member)) {
-                    logging_1.default.info({
-                        system: {
-                            event: 'automations.poll.skipped_unsubscribed_member',
-                            member_id: step.member_id,
-                            step_id: step.id
-                        }
-                    }, `[AUTOMATIONS] Member ${step.member_id} for step ${step.id} has unsubscribed from emails. Fast-finishing this step`);
-                    break;
+                    await automationsApi.markStepTerminal(step, 'member unsubscribed');
+                    return null;
                 }
                 memberWelcomeEmailService.init();
                 const trackClicks = labs.isSet('automationAnalytics') && Boolean(settingsCache.get('email_track_clicks'));

package/core/server/services/comments/comments-service.js

@@ -17,8 +17,7 @@ const messages = {
     cannotEditComment: 'You do not have permission to edit comments',
     cannotPinReply: 'Replies cannot be pinned',
     cannotPinDeletedComment: 'Deleted comments cannot be pinned',
-    invalidPinnedValue: 'Pinned must be a boolean value',
-    commentsPinningNotEnabled: 'Comment pinning is not enabled for this site.'
+    invalidPinnedValue: 'Pinned must be a boolean value'
 };
 
 const COMMENT_LIKE_SCORE = 1;
@@ -94,13 +93,10 @@ function getSafeWriteOptions(options = {}) {
 }
 
 class CommentsService {
-    constructor({config, logging, models, mailer, settingsCache, settingsHelpers, urlService, urlUtils, contentGating, labs}) {
+    constructor({config, logging, models, mailer, settingsCache, settingsHelpers, urlService, urlUtils, contentGating}) {
         /** @private */
         this.models = models;
 
-        /** @private */
-        this.labs = labs;
-
         /** @private */
         this.settingsCache = settingsCache;
 
@@ -445,8 +441,7 @@ class CommentsService {
      */
     async getComments(options) {
         this.checkEnabled();
-        const pinnedFirst = this.labs?.isSet('commentsPinning');
-        const page = await this.models.Comment.findPage(withPinnedSelect({...options, parentId: null, pinnedFirst}));
+        const page = await this.models.Comment.findPage(withPinnedSelect({...options, parentId: null, pinnedFirst: true}));
 
         return page;
     }
@@ -492,12 +487,11 @@ class CommentsService {
 
     async getAdminComments(options) {
         this.checkEnabled();
-        const pinnedFirst = this.labs?.isSet('commentsPinning');
         const page = await this.models.Comment.findPage(withPinnedSelect({
             ...options,
             parentId: null,
             isAdmin: true,
-            pinnedFirst
+            pinnedFirst: true
         }, {includeHidden: true}));
 
         return page;
@@ -515,12 +509,6 @@ class CommentsService {
         }
 
         if (Object.prototype.hasOwnProperty.call(data, 'pinned')) {
-            if (!this.labs?.isSet('commentsPinning')) {
-                throw new errors.MethodNotAllowedError({
-                    message: tpl(messages.commentsPinningNotEnabled)
-                });
-            }
-
             if (typeof data.pinned !== 'boolean') {
                 throw new errors.BadRequestError({
                     message: tpl(messages.invalidPinnedValue)

package/core/server/services/comments/index.js

@@ -15,7 +15,6 @@ class CommentsServiceWrapper {
         const membersService = require('../members');
         const db = require('../../data/db');
         const settingsHelpers = require('../settings-helpers');
-        const labs = require('../../../shared/labs');
 
         this.api = new CommentsService({
             config,
@@ -26,8 +25,7 @@ class CommentsServiceWrapper {
             settingsHelpers,
             urlService,
             urlUtils,
-            contentGating: membersService.contentGating,
-            labs
+            contentGating: membersService.contentGating
         });
 
         const stats = new CommentsStats({db});

package/core/server/services/email-analytics/email-analytics-service-wrapper.js

@@ -1,95 +1,73 @@
-const logging = require('@tryghost/logging');
-const metrics = require('@tryghost/metrics');
-const config = require('../../../shared/config');
-const domainEvents = require('@tryghost/domain-events');
-/** @import {PrometheusClient} from '@tryghost/prometheus-metrics' */
-/** @import {BatchEventProcessor} from './batch-event-processor' */
-/** @import {JobNames, CursorSeed, EmailAnalyticsFetchResult} from './email-analytics-service' */
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailAnalyticsServiceWrapper = void 0;
+const errors_1 = __importDefault(require("@tryghost/errors"));
+const logging_1 = __importDefault(require("@tryghost/logging"));
+const email_analytics_service_1 = require("./email-analytics-service");
+const fetch_mailgun_events_1 = require("./fetch-mailgun-events");
 class EmailAnalyticsServiceWrapper {
-    /** @type {string} */ #logName;
+    #logName;
+    #config;
+    #metrics;
+    #service;
     #fetching = false;
     #restoredSchedule = false;
-
     get #logPrefix() {
         return `[EmailAnalytics:${this.#logName}]`;
     }
-
-    /**
-     * @param {object} options
-     * @param {string} options.logName
-     */
-    constructor({
-        logName,
-    }) {
+    constructor({ logName }) {
         this.#logName = logName;
     }
-
-    /**
-     * @param {object} options
-     * @param {Parameters<typeof domainEvents.subscribe>[0]} options.event
-     * @param {string[]} options.mailgunTags
-     * @param {JobNames} options.jobNames
-     * @param {CursorSeed} options.cursorSeed
-     * @param {() => BatchEventProcessor} options.createEventProcessor
-     * @param {PrometheusClient} [options.prometheusClient]
-     */
-    init({
-        event,
-        mailgunTags,
-        jobNames,
-        cursorSeed,
-        createEventProcessor,
-        prometheusClient
-    }) {
-        if (this.service) {
+    init({ config, domainEvents, event, queries, mailgunTags, jobNames, cursorSeed, createEventProcessor, metrics, settingsCache }) {
+        if (this.#service) {
             return;
         }
-
-        const EmailAnalyticsService = require('./email-analytics-service');
-        const MailgunProvider = require('./email-analytics-provider-mailgun');
-        const settings = require('../../../shared/settings-cache');
-        const {queries} = require('./lib/queries');
-
-        this.service = new EmailAnalyticsService({
-            provider: new MailgunProvider({config, settings, tags: mailgunTags}),
+        this.#config = config;
+        this.#metrics = metrics;
+        this.#service = new email_analytics_service_1.EmailAnalyticsService({
+            fetchEvents: (options) => (0, fetch_mailgun_events_1.fetchMailgunEvents)({ ...options, config, settings: settingsCache, tags: mailgunTags }),
             queries,
-            prometheusClient,
             jobNames,
             cursorSeed,
             createEventProcessor
         });
-
         // Log the processing mode on initialization
-        const batchProcessingEnabled = config.get('emailAnalytics:batchProcessing');
-        logging.info(`${this.#logPrefix} Initialized with ${batchProcessingEnabled ? 'BATCHED' : 'SEQUENTIAL'} processing mode`);
-
+        const batchProcessingEnabled = this.#config.get('emailAnalytics:batchProcessing');
+        logging_1.default.info(`${this.#logPrefix} Initialized with ${batchProcessingEnabled ? 'BATCHED' : 'SEQUENTIAL'} processing mode`);
         // We currently cannot trigger a non-offloaded job from the job manager
         // So the email analytics jobs simply emits an event.
         domainEvents.subscribe(event, async () => {
             await this.startFetch();
         });
     }
-
-    /**
-     * Log comprehensive job completion with timing metrics
-     * @param {string} jobType - Type of job (e.g., 'latest-opened', 'latest', 'missing', 'scheduled')
-     * @param {EmailAnalyticsFetchResult} fetchResult - The fetch result from EmailAnalyticsService
-     * @param {number} totalDurationMs - Total duration in milliseconds
-     */
+    get service() {
+        const result = this.#service;
+        if (!result) {
+            throw new errors_1.default.InternalServerError({ message: "EmailAnalyticsServiceWrapper is not initialized with service" });
+        }
+        return result;
+    }
+    #getConfig() {
+        const result = this.#config;
+        if (!result) {
+            throw new errors_1.default.InternalServerError({ message: "EmailAnalyticsServiceWrapper is not initialized with config" });
+        }
+        return result;
+    }
     _logJobCompletion(jobType, fetchResult, totalDurationMs) {
-        const {eventCount, apiPollingTimeMs, processingTimeMs, aggregationTimeMs, emailAggregationTimeMs, memberAggregationTimeMs, result} = fetchResult;
-
+        const config = this.#getConfig();
+        const { eventCount, apiPollingTimeMs, processingTimeMs, aggregationTimeMs, emailAggregationTimeMs, memberAggregationTimeMs, result } = fetchResult;
         if (eventCount === 0) {
             return;
         }
-
         const throughput = totalDurationMs > 0 ? eventCount / (totalDurationMs / 1000) : 0;
         const apiPercent = totalDurationMs > 0 ? Math.round((apiPollingTimeMs / totalDurationMs) * 100) : 0;
         const processingPercent = totalDurationMs > 0 ? Math.round((processingTimeMs / totalDurationMs) * 100) : 0;
         const aggregationPercent = totalDurationMs > 0 ? Math.round((aggregationTimeMs / totalDurationMs) * 100) : 0;
         const batchMode = config.get('emailAnalytics:batchProcessing') ? 'BATCHED' : 'SEQUENTIAL';
-
         const logMessage = [
             `${this.#logPrefix} Job complete: ${jobType}`,
             `${eventCount} events in ${(totalDurationMs / 1000).toFixed(1)}s (${throughput.toFixed(2)} events/s)`,
@@ -97,9 +75,7 @@ class EmailAnalyticsServiceWrapper {
             `Timings: API ${(apiPollingTimeMs / 1000).toFixed(1)}s (${apiPercent}%) / Processing ${(processingTimeMs / 1000).toFixed(1)}s (${processingPercent}%) / Aggregation ${(aggregationTimeMs / 1000).toFixed(1)}s (${aggregationPercent}%) [Email ${(emailAggregationTimeMs / 1000).toFixed(1)}s / Member ${(memberAggregationTimeMs / 1000).toFixed(1)}s]`,
             `Events: opened=${result.opened} delivered=${result.delivered} failed=${result.permanentFailed + result.temporaryFailed} unprocessable=${result.unprocessable}`
         ].join(' | ');
-
-        logging.info(logMessage);
-
+        logging_1.default.info(logMessage);
         // We're only concerned with open throughput as this is displayed to users and is most sensitive to being up to date
         if (jobType === 'latest-opened') {
             const openThroughputEnabled = config.get('emailAnalytics:metrics:openThroughput:enabled');
@@ -108,6 +84,12 @@ class EmailAnalyticsServiceWrapper {
                 const metricName = this.#logName === 'newsletters'
                     ? 'email-analytics-open-throughput'
                     : `email-${this.#logName}-analytics-open-throughput`;
+                const metrics = this.#metrics;
+                if (!metrics) {
+                    throw new errors_1.default.InternalServerError({
+                        message: 'EmailAnalyticsServiceWrapper is not initialized with metrics'
+                    });
+                }
                 metrics.metric(metricName, {
                     value: throughput,
                     events: eventCount,
@@ -116,131 +98,98 @@ class EmailAnalyticsServiceWrapper {
             }
         }
     }
-
-    async fetchLatestOpenedEvents({maxEvents} = {maxEvents: Infinity}) {
+    async fetchLatestOpenedEvents({ maxEvents = Infinity } = {}) {
+        const config = this.#getConfig();
         const beginTimestamp = await this.service.getLastOpenedEventTimestamp();
         const lagMinutes = (Date.now() - beginTimestamp.getTime()) / 60000;
         const lagThreshold = config.get('emailAnalytics:openedJobLagWarningMinutes');
-
         // NOTE: We only update the begin timestamp when we process events, so there's cases where we can have a false positive
         //  - Ghost or Mailgun outages
         //  - Lack of actual email activity
         if (lagThreshold && lagMinutes > lagThreshold) {
-            logging.warn(`${this.#logPrefix} Opened events processing is ${lagMinutes.toFixed(1)} minutes behind (threshold: ${lagThreshold})`);
+            logging_1.default.warn(`${this.#logPrefix} Opened events processing is ${lagMinutes.toFixed(1)} minutes behind (threshold: ${lagThreshold})`);
         }
-
         const fetchStartedAt = Date.now();
-        const fetchResult = await this.service.fetchLatestOpenedEvents({maxEvents});
+        const fetchResult = await this.service.fetchLatestOpenedEvents({ maxEvents });
         const totalDuration = Date.now() - fetchStartedAt;
-
         this._logJobCompletion('latest-opened', fetchResult, totalDuration);
-
         return fetchResult.eventCount;
     }
-
-    async fetchLatestNonOpenedEvents({maxEvents} = {maxEvents: Infinity}) {
+    async fetchLatestNonOpenedEvents({ maxEvents = Infinity } = {}) {
         const fetchStartedAt = Date.now();
-        const fetchResult = await this.service.fetchLatestNonOpenedEvents({maxEvents});
+        const fetchResult = await this.service.fetchLatestNonOpenedEvents({ maxEvents });
         const totalDuration = Date.now() - fetchStartedAt;
-
         this._logJobCompletion('latest', fetchResult, totalDuration);
-
         return fetchResult.eventCount;
     }
-
-    async fetchMissing({maxEvents} = {maxEvents: Infinity}) {
+    async fetchMissing({ maxEvents = Infinity } = {}) {
         const fetchStartedAt = Date.now();
-        const fetchResult = await this.service.fetchMissing({maxEvents});
+        const fetchResult = await this.service.fetchMissing({ maxEvents });
         const totalDuration = Date.now() - fetchStartedAt;
-
         this._logJobCompletion('missing', fetchResult, totalDuration);
-
         return fetchResult.eventCount;
     }
-
-    /**
-     * @param {object} options
-     * @param {number} options.maxEvents
-     * @returns {Promise<number>} The number of scheduled events fetched
-     */
-    async fetchScheduled({maxEvents}) {
+    async fetchScheduled({ maxEvents }) {
         if (maxEvents < 300) {
             return 0;
         }
-
         const fetchStartedAt = Date.now();
-        const fetchResult = await this.service.fetchScheduled({maxEvents});
+        const fetchResult = await this.service.fetchScheduled({ maxEvents });
         const totalDuration = Date.now() - fetchStartedAt;
-
         this._logJobCompletion('scheduled', fetchResult, totalDuration);
-
         return fetchResult.eventCount;
     }
-
     async startFetch() {
         if (!this.#restoredSchedule) {
             this.#restoredSchedule = true;
             await this.service.restoreScheduled();
         }
-
         if (this.#fetching) {
-            logging.info(`Email analytics fetch for ${this.#logName} already running, skipping`);
+            logging_1.default.info(`Email analytics fetch for ${this.#logName} already running, skipping`);
             return;
         }
         this.#fetching = true;
-
         // NOTE: Data shows we can process ~2500 events per minute on Pro for a large-ish db (150k members).
         //       This can vary locally, but we should be conservative with the number of events we fetch.
         try {
             // Prioritize opens since they are the most important (only data directly displayed to users)
-            const c1 = await this.fetchLatestOpenedEvents({maxEvents: 10000});
+            const c1 = await this.fetchLatestOpenedEvents({ maxEvents: 10000 });
             if (c1 >= 10000) {
                 this._restartFetch('high opened event count');
                 return;
             }
-
             // Set limits on how much we fetch without checkings for opened events. During surge events (following newsletter send)
             //  we want to make sure we don't spend too much time collecting delivery data.
-            const c2 = await this.fetchLatestNonOpenedEvents({maxEvents: 10000 - c1});
-            const c3 = await this.fetchMissing({maxEvents: 10000 - c1 - c2});
-
+            const c2 = await this.fetchLatestNonOpenedEvents({ maxEvents: 10000 - c1 });
+            const c3 = await this.fetchMissing({ maxEvents: 10000 - c1 - c2 });
             // Always restart immediately instead of waiting for the next scheduled job if we're fetching a lot of events
             if ((c1 + c2 + c3) > 10000) {
                 this._restartFetch('high event count');
                 return;
             }
-
             // Only backfill if we're not currently fetching a lot of events
-            const c4 = await this.fetchScheduled({maxEvents: 10000});
+            const c4 = await this.fetchScheduled({ maxEvents: 10000 });
             if (c4 > 0) {
                 this._restartFetch('scheduled backfill');
                 return;
             }
-
             // Log summary if no events were found across all jobs
             if (c1 + c2 + c3 + c4 === 0) {
-                logging.info(`${this.#logPrefix} Job complete - No events`);
+                logging_1.default.info(`${this.#logPrefix} Job complete - No events`);
             }
-
             this.#fetching = false;
-        } catch (e) {
-            logging.error(e, `Error while fetching email analytics for ${this.#logName}`);
-
+        }
+        catch (e) {
+            logging_1.default.error(e, `Error while fetching email analytics for ${this.#logName}`);
             // Log again only the error, otherwise we lose the stack trace
-            logging.error(e);
+            logging_1.default.error(e);
         }
         this.#fetching = false;
     }
-
-    /**
-     * @param {string} reason
-     * @returns {void}
-     */
     _restartFetch(reason) {
         this.#fetching = false;
-        logging.info(`${this.#logPrefix} Restarting fetch due to ${reason}`);
+        logging_1.default.info(`${this.#logPrefix} Restarting fetch due to ${reason}`);
         this.startFetch();
     }
 }
-
-module.exports = EmailAnalyticsServiceWrapper;
+exports.EmailAnalyticsServiceWrapper = EmailAnalyticsServiceWrapper;