ghost 6.57.0 → 6.57.1

package/core/server/services/email-analytics/lib/queries.ts

@@ -0,0 +1,341 @@
+import _ from 'lodash';
+import debugFactory from '@tryghost/debug';
+// @ts-expect-error This module lacks type definitions.
+import db from '../../../data/db';
+import logging from '@tryghost/logging';
+import ObjectID from 'bson-objectid';
+
+const debug = debugFactory('services:email-analytics');
+
+const MIN_EMAIL_COUNT_FOR_OPEN_RATE = 5;
+
+type EmailAnalyticsJobName = string;
+type EmailAnalyticsEvent = 'delivered' | 'opened' | 'failed';
+type CursorSeed = {
+    tableName: string;
+    eventColumns: Partial<Record<EmailAnalyticsEvent, string>>;
+};
+
+/**
+ * Creates a job in the jobs table if it does not already exist.
+ * @param jobName - The name of the job to create.
+ */
+async function createJobIfNotExists(jobName: EmailAnalyticsJobName): Promise<void> {
+    await db.knex('jobs').insert({
+        id: new ObjectID().toHexString(),
+        name: jobName,
+        started_at: new Date(),
+        created_at: new Date(),
+        status: 'started'
+    }).onConflict('name').ignore();
+}
+
+export const queries = {
+    /**
+     * Retrieves the timestamp of the last seen event for the specified email analytics events.
+     * @param jobName - The name of the job to update.
+     * @param events - The email analytics events to consider.
+     * @param cursorSeed - Recipient table and timestamp columns to read the initial cursor from. Used when the job has no stored timestamp yet.
+     * @returns The timestamp of the last seen event, or null if no events are found.
+     */
+    async getLastEventTimestamp(
+        jobName: EmailAnalyticsJobName,
+        events: EmailAnalyticsEvent[],
+        cursorSeed: CursorSeed
+    ): Promise<Date | null> {
+        const startDate = new Date();
+
+        let timestamps: (Date | string | null)[] = [];
+        const lastJobRunTimestamp = await this.getLastJobRunTimestamp(jobName);
+
+        if (lastJobRunTimestamp) {
+            debug(`Using job data for ${jobName}`);
+            timestamps = [lastJobRunTimestamp];
+        } else {
+            debug(`Job data not found for ${jobName}, using ${cursorSeed.tableName} data`);
+            logging.info(`Job data not found for ${jobName}, using ${cursorSeed.tableName} data`);
+
+            for (const event of events) {
+                const columnName = cursorSeed.eventColumns[event];
+                if (!columnName) {
+                    continue;
+                }
+                const row = await db.knex(cursorSeed.tableName)
+                    .select(db.knex.raw('MAX(??) as maxTimestamp', [columnName]))
+                    .first();
+                timestamps.push(row.maxTimestamp);
+            }
+
+            await createJobIfNotExists(jobName);
+        }
+
+        // Convert string dates to Date objects for SQLite compatibility
+        const normalizedTimestamps = timestamps.map(date => {
+            if (!date) {
+                return null;
+            }
+            return date instanceof Date ? date : new Date(date);
+        });
+
+        const lastSeenEventTimestamp = _.max(normalizedTimestamps) ?? null;
+        debug(`getLastEventTimestamp: finished in ${Date.now() - startDate.getTime()}ms`);
+
+        return lastSeenEventTimestamp;
+    },
+
+    /**
+     * Retrieves the job data for the specified job name.
+     * @param jobName - The name of the job to retrieve data for.
+     * @returns The job data, or null if no job data is found.
+     */
+    async getJobData(jobName: EmailAnalyticsJobName) {
+        return await db.knex('jobs').select('finished_at', 'started_at', 'metadata').where('name', jobName).first();
+    },
+
+    /**
+     * Retrieves the timestamp of the last job run for the specified job name.
+     * @param jobName - The name of the job to retrieve the last run timestamp for.
+     * @returns The timestamp of the last job run, or null if no job data is found.
+     */
+    async getLastJobRunTimestamp(jobName: EmailAnalyticsJobName): Promise<Date | null> {
+        const jobData = await this.getJobData(jobName);
+        return jobData ? jobData.finished_at || jobData.started_at : null;
+    },
+
+    /**
+     * Sets the timestamp of the last seen event for the specified email analytics events.
+     * @param jobName - The name of the job to update.
+     * @param field - The field to update.
+     * @param date - The timestamp of the last seen event.
+     * @description
+     * Updates the `finished_at` or `started_at` column of the specified job in the `jobs` table with the provided timestamp.
+     * This is used to keep track of the last time the job was run to avoid expensive queries following reboot.
+     */
+    async setJobTimestamp(jobName: EmailAnalyticsJobName, field: 'finished' | 'started', date: Date): Promise<void> {
+        // Convert string dates to Date objects for SQLite compatibility
+        try {
+            debug(`Setting ${field} timestamp for job ${jobName} to ${date}`);
+            const updateField = field === 'finished' ? 'finished_at' : 'started_at';
+            const status = field === 'finished' ? 'finished' : 'started';
+            const result = await db.knex('jobs').update({[updateField]: date, updated_at: new Date(), status: status}).where('name', jobName);
+            if (result === 0) {
+                await db.knex('jobs').insert({
+                    id: new ObjectID().toHexString(),
+                    name: jobName,
+                    [updateField]: date.toISOString(), // force to iso string for sqlite
+                    updated_at: date.toISOString(), // force to iso string for sqlite
+                    status: status
+                });
+            }
+        } catch (err: unknown) {
+            const message = err instanceof Error ? err.message : String(err);
+            debug(`Error setting ${field} timestamp for job ${jobName}: ${message}`);
+        }
+    },
+
+    /**
+     * Retrieves and parses the metadata JSON for the specified job.
+     * @param jobName - The name of the job.
+     * @returns The parsed metadata object, or null.
+     */
+    async getJobMetadata(jobName: EmailAnalyticsJobName): Promise<object | null> {
+        try {
+            const row = await db.knex('jobs').select('metadata').where('name', jobName).first();
+            if (row && row.metadata) {
+                return JSON.parse(row.metadata);
+            }
+        } catch (err: unknown) {
+            const message = err instanceof Error ? err.message : String(err);
+            logging.error(`Error reading metadata for job ${jobName}: ${message}`);
+        }
+        return null;
+    },
+
+    /**
+     * Writes metadata JSON for the specified job.
+     * @param jobName - The name of the job.
+     * @param metadata - The metadata to store, or null to clear.
+     */
+    async setJobMetadata(jobName: EmailAnalyticsJobName, metadata: object | null): Promise<void> {
+        try {
+            const value = metadata ? JSON.stringify(metadata) : null;
+            await db.knex.transaction(async (trx: typeof db.knex) => {
+                const result = await trx('jobs').update({metadata: value, updated_at: new Date()}).where('name', jobName);
+                if (result === 0 && metadata) {
+                    await trx('jobs').insert({
+                        id: new ObjectID().toHexString(),
+                        name: jobName,
+                        metadata: value,
+                        created_at: new Date(),
+                        status: 'queued'
+                    });
+                }
+            });
+        } catch (err: unknown) {
+            const message = err instanceof Error ? err.message : String(err);
+            logging.error(`Error setting metadata for job ${jobName}: ${message}`);
+        }
+    },
+
+    /**
+     * Sets the status of the specified email analytics job.
+     * @param jobName - The name of the job to update.
+     * @param status - The new status of the job.
+     * @description
+     * Updates the `status` column of the specified job in the `jobs` table with the provided status.
+     * This is used to keep track of the current state of the job.
+     */
+    async setJobStatus(jobName: EmailAnalyticsJobName, status: 'started' | 'finished' | 'failed'): Promise<void> {
+        debug(`Setting status for job ${jobName} to ${status}`);
+        try {
+            const result = await db.knex('jobs')
+                .update({
+                    status: status,
+                    updated_at: new Date()
+                })
+                .where('name', jobName);
+
+            if (result === 0) {
+                await db.knex('jobs').insert({
+                    id: new ObjectID().toHexString(),
+                    name: jobName,
+                    status: status,
+                    created_at: new Date(),
+                    updated_at: new Date()
+                });
+            }
+        } catch (err: unknown) {
+            const message = err instanceof Error ? err.message : String(err);
+            debug(`Error setting status for job ${jobName}: ${message}`);
+            throw err;
+        }
+    },
+
+    async aggregateEmailStats(emailId: string, updateOpenedCount: boolean): Promise<void> {
+        const [deliveredCount] = await db.knex('email_recipients').count('id as count').whereRaw('email_id = ? AND delivered_at IS NOT NULL', [emailId]);
+        const [failedCount] = await db.knex('email_recipients').count('id as count').whereRaw('email_id = ? AND failed_at IS NOT NULL', [emailId]);
+
+        const updateData: Record<string, string | number> = {
+            delivered_count: deliveredCount.count,
+            failed_count: failedCount.count
+        };
+
+        if (updateOpenedCount) {
+            const [openedCount] = await db.knex('email_recipients').count('id as count').whereRaw('email_id = ? AND opened_at IS NOT NULL', [emailId]);
+            updateData.opened_count = openedCount.count;
+        }
+
+        await db.knex('emails').update(updateData).where('id', emailId);
+    },
+
+    async aggregateMemberStats(memberId: string): Promise<void> {
+        const {trackedEmailCount} = await db.knex('email_recipients')
+            .select(db.knex.raw('COUNT(email_recipients.id) as trackedEmailCount'))
+            .leftJoin('emails', 'email_recipients.email_id', 'emails.id')
+            .where('email_recipients.member_id', memberId)
+            .where('emails.track_opens', true)
+            .first() || {};
+
+        const [emailCount] = await db.knex('email_recipients').count('id as count').whereRaw('member_id = ?', [memberId]);
+        const [emailOpenedCount] = await db.knex('email_recipients').count('id as count').whereRaw('member_id = ? AND opened_at IS NOT NULL', [memberId]);
+
+        const updateQuery: Record<string, string | number> = {
+            email_count: emailCount.count,
+            email_opened_count: emailOpenedCount.count
+        };
+
+        if (trackedEmailCount >= MIN_EMAIL_COUNT_FOR_OPEN_RATE) {
+            updateQuery.email_open_rate = Math.round(emailOpenedCount.count / trackedEmailCount * 100);
+        }
+
+        await db.knex('members')
+            .update(updateQuery)
+            .where('id', memberId);
+    },
+
+    async aggregateMemberStatsBatch(memberIds: string[]): Promise<void> {
+        if (!memberIds || memberIds.length === 0) {
+            return;
+        }
+
+        // Batch query to get stats for all members at once
+        const stats = await db.knex('email_recipients')
+            .leftJoin('emails', 'emails.id', 'email_recipients.email_id')
+            .select(
+                'email_recipients.member_id',
+                db.knex.raw('COUNT(email_recipients.id) as email_count'),
+                db.knex.raw('SUM(CASE WHEN email_recipients.opened_at IS NOT NULL THEN 1 ELSE 0 END) as email_opened_count'),
+                db.knex.raw('SUM(CASE WHEN emails.track_opens = 1 THEN 1 ELSE 0 END) as tracked_count')
+            )
+            .whereIn('email_recipients.member_id', memberIds)
+            .groupBy('email_recipients.member_id');
+
+        // Build update data for each member
+        const memberStatsMap = new Map<string, {email_count: number; email_opened_count: number; email_open_rate: number | null}>();
+        for (const stat of stats) {
+            const emailOpenRate = stat.tracked_count >= MIN_EMAIL_COUNT_FOR_OPEN_RATE
+                ? Math.round((stat.email_opened_count / stat.tracked_count) * 100)
+                : null;
+
+            memberStatsMap.set(stat.member_id, {
+                email_count: stat.email_count,
+                email_opened_count: stat.email_opened_count,
+                email_open_rate: emailOpenRate
+            });
+        }
+
+        // Build CASE statements for batch update
+        const emailCountCases: string[] = [];
+        const emailOpenedCountCases: string[] = [];
+        const emailOpenRateCases: string[] = [];
+        const emailCountBindings: (string | number)[] = [];
+        const emailOpenedCountBindings: (string | number)[] = [];
+        const emailOpenRateBindings: (string | number)[] = [];
+
+        for (const memberId of memberIds) {
+            const memberStats = memberStatsMap.get(memberId) || {
+                email_count: 0,
+                email_opened_count: 0,
+                email_open_rate: null
+            };
+
+            emailCountCases.push(`WHEN ? THEN ?`);
+            emailCountBindings.push(memberId, memberStats.email_count);
+
+            emailOpenedCountCases.push(`WHEN ? THEN ?`);
+            emailOpenedCountBindings.push(memberId, memberStats.email_opened_count);
+
+            if (memberStats.email_open_rate !== null) {
+                emailOpenRateCases.push(`WHEN ? THEN ?`);
+                emailOpenRateBindings.push(memberId, memberStats.email_open_rate);
+            } else {
+                emailOpenRateCases.push(`WHEN ? THEN NULL`);
+                emailOpenRateBindings.push(memberId);
+            }
+        }
+
+        // Combine bindings in the order they appear in the SQL statement:
+        // 1. All bindings for email_count CASE statement
+        // 2. All bindings for email_opened_count CASE statement
+        // 3. All bindings for email_open_rate CASE statement
+        // 4. Member IDs for the WHERE IN clause
+        const bindings = [
+            ...emailCountBindings,
+            ...emailOpenedCountBindings,
+            ...emailOpenRateBindings,
+            ...memberIds
+        ];
+
+        // Execute batched update with CASE statements
+        await db.knex.raw(`
+            UPDATE members
+            SET
+                email_count = CASE id ${emailCountCases.join(' ')} END,
+                email_opened_count = CASE id ${emailOpenedCountCases.join(' ')} END,
+                email_open_rate = CASE id ${emailOpenRateCases.join(' ')} END
+            WHERE id IN (${memberIds.map(() => '?').join(',')})
+        `, bindings);
+    }
+};
+
+export type Queries = typeof queries;

package/core/server/services/indexnow-ping/index.js

@@ -11,7 +11,6 @@ class IndexNowPingServiceWrapper {
         // Wire up all the dependencies
         const settingsCache = require('../../../shared/settings-cache');
         const config = require('../../../shared/config');
-        const labs = require('../../../shared/labs');
         const urlService = require('../url');
         const urlUtils = require('../../../shared/url-utils').default;
         const request = require('@tryghost/request');
@@ -20,7 +19,6 @@ class IndexNowPingServiceWrapper {
         this.service = new indexnow_ping_service_1.IndexNowPingService({
             settingsCache,
             config,
-            labs,
             urlService,
             urlUtils,
             request,

package/core/server/services/indexnow-ping/index.ts

@@ -12,7 +12,6 @@ class IndexNowPingServiceWrapper {
         // Wire up all the dependencies
         const settingsCache = require('../../../shared/settings-cache');
         const config = require('../../../shared/config');
-        const labs = require('../../../shared/labs');
         const urlService = require('../url');
         const urlUtils = require('../../../shared/url-utils').default;
         const request = require('@tryghost/request');
@@ -22,7 +21,6 @@ class IndexNowPingServiceWrapper {
         this.service = new IndexNowPingService({
             settingsCache,
             config,
-            labs,
             urlService,
             urlUtils,
             request,

package/core/server/services/indexnow-ping/indexnow-ping-service.js

@@ -31,17 +31,15 @@ const constants_1 = require("./constants");
 class IndexNowPingService {
     settingsCache;
     config;
-    labs;
     urlService;
     urlUtils;
     request;
     logging;
     events;
     listener;
-    constructor({ settingsCache, config, labs, urlService, urlUtils, request, logging, events }) {
+    constructor({ settingsCache, config, urlService, urlUtils, request, logging, events }) {
         this.settingsCache = settingsCache;
         this.config = config;
-        this.labs = labs;
         this.urlService = urlService;
         this.urlUtils = urlUtils;
         this.request = request;
@@ -68,6 +66,10 @@ class IndexNowPingService {
      * Ping IndexNow with a URL.
      */
     async ping(post) {
+        // Skip if in development
+        if (this.config.get('env') === 'development') {
+            return;
+        }
         // Skip pages - only ping for posts
         if (post.type === 'page') {
             return;
@@ -80,10 +82,6 @@ class IndexNowPingService {
         if (this.config.isPrivacyDisabled('useIndexNow')) {
             return;
         }
-        // Skip if IndexNow is not enabled in labs
-        if (!this.labs.isSet('indexnow')) {
-            return;
-        }
         // Don't ping for the default posts
         if (post.slug && constants_1.defaultPostSlugs.indexOf(post.slug) > -1) {
             return;

package/core/server/services/indexnow-ping/indexnow-ping-service.ts

@@ -36,13 +36,10 @@ type SettingsCache = {
 };
 
 type Config = {
+    get(key: string): unknown;
     isPrivacyDisabled(key: string): boolean;
 };
 
-type Labs = {
-    isSet(flag: string): boolean;
-};
-
 type UrlService = {
     getUrlForResource(resource: Record<string, unknown>, options: {absolute: boolean}): string | null;
 };
@@ -84,7 +81,6 @@ type Post = {
 export type IndexNowPingServiceDeps = {
     settingsCache: SettingsCache;
     config: Config;
-    labs: Labs;
     urlService: UrlService;
     urlUtils: UrlUtils;
     request: RequestFn;
@@ -95,7 +91,6 @@ export type IndexNowPingServiceDeps = {
 export class IndexNowPingService {
     settingsCache: SettingsCache;
     config: Config;
-    labs: Labs;
     urlService: UrlService;
     urlUtils: UrlUtils;
     request: RequestFn;
@@ -103,10 +98,9 @@ export class IndexNowPingService {
     events: ModelEvents;
     listener: ModelEventListener;
 
-    constructor({settingsCache, config, labs, urlService, urlUtils, request, logging, events}: IndexNowPingServiceDeps) {
+    constructor({settingsCache, config, urlService, urlUtils, request, logging, events}: IndexNowPingServiceDeps) {
         this.settingsCache = settingsCache;
         this.config = config;
-        this.labs = labs;
         this.urlService = urlService;
         this.urlUtils = urlUtils;
         this.request = request;
@@ -137,6 +131,11 @@ export class IndexNowPingService {
      * Ping IndexNow with a URL.
      */
     async ping(post: Post): Promise<void> {
+        // Skip if in development
+        if (this.config.get('env') === 'development') {
+            return;
+        }
+
         // Skip pages - only ping for posts
         if (post.type === 'page') {
             return;
@@ -152,11 +151,6 @@ export class IndexNowPingService {
             return;
         }
 
-        // Skip if IndexNow is not enabled in labs
-        if (!this.labs.isSet('indexnow')) {
-            return;
-        }
-
         // Don't ping for the default posts
         if (post.slug && defaultPostSlugs.indexOf(post.slug) > -1) {
             return;

package/core/server/services/members/members-api/repositories/member-repository.js

@@ -1256,6 +1256,11 @@ module.exports = class MemberRepository {
         };
         let eventData = {};
 
+        // A cancellation (or reactivation) changes no `members` column, so the member
+        // model event would be suppressed by `wasChanged()`. Remember the pre-update
+        // subscription so the event can be marked and carry its prior state.
+        let subscriptionBeforeCancelFlagChange = null;
+
         const stripeCustomerSubscriptionModelShouldBeDeleted = stripeSubscriptionData.metadata && !!stripeSubscriptionData.metadata.ghost_migrated_to && stripeSubscriptionData.status === 'canceled';
         if (stripeCustomerSubscriptionModelShouldBeDeleted) {
             logging.warn(`Subscription ${subscriptionData.subscription_id} is marked for deletion, skipping linking.`);
@@ -1300,6 +1305,10 @@ module.exports = class MemberRepository {
                 this.dispatchEvent(offerRedemptionEvent, options);
             }
 
+            if (stripeCustomerSubscriptionModel.get('cancel_at_period_end') !== updatedStripeCustomerSubscriptionModel.get('cancel_at_period_end')) {
+                subscriptionBeforeCancelFlagChange = stripeCustomerSubscriptionModel;
+            }
+
             if (stripeCustomerSubscriptionModel.get('mrr') !== updatedStripeCustomerSubscriptionModel.get('mrr') || stripeCustomerSubscriptionModel.get('plan_id') !== updatedStripeCustomerSubscriptionModel.get('plan_id') || stripeCustomerSubscriptionModel.get('status') !== updatedStripeCustomerSubscriptionModel.get('status') || stripeCustomerSubscriptionModel.get('cancel_at_period_end') !== updatedStripeCustomerSubscriptionModel.get('cancel_at_period_end')) {
                 const originalMrrDelta = stripeCustomerSubscriptionModel.get('mrr');
                 const updatedMrrDelta = updatedStripeCustomerSubscriptionModel.get('mrr');
@@ -1550,6 +1559,48 @@ module.exports = class MemberRepository {
             updatedMember = await this._Member.edit({status: status}, {...options, id: data.id});
         }
 
+        // Cancelling (or reactivating) touches no `members` column, so mark the
+        // subscription relation as the change and carry its prior state. This lets the
+        // webhook payload express before/after — see `services/webhooks/serialize.js`.
+        //
+        // No explicit `emitChange` is needed, and adding one would emit twice: inside a
+        // transaction `emitChange` queues onto the `committed` handler and defers its
+        // `wasChanged()` check to commit time (see `models/base/plugins/events.js`), so
+        // the event already queued by `_Member.edit` above is still pending and setting
+        // `_changed` here is what lets it through. The e2e test asserting exactly one
+        // `member.edited` per cancellation guards this.
+        if (subscriptionBeforeCancelFlagChange && updatedMember) {
+            // Price/tier relations are needed for the serialized subscription shape
+            // to match the Admin API member resource (price, tier, plan)
+            await updatedMember.load([
+                'stripeSubscriptions',
+                'stripeSubscriptions.stripePrice',
+                'stripeSubscriptions.stripePrice.stripeProduct',
+                'stripeSubscriptions.stripePrice.stripeProduct.product'
+            ], options);
+            await subscriptionBeforeCancelFlagChange.load([
+                'stripePrice',
+                'stripePrice.stripeProduct',
+                'stripePrice.stripeProduct.product'
+            ], options);
+            updatedMember._changed = {
+                ...updatedMember._changed,
+                stripeSubscriptions: {
+                    cancel_at_period_end: subscriptionBeforeCancelFlagChange.get('cancel_at_period_end')
+                }
+            };
+            // `previous` must be the full collection — a member can have multiple
+            // subscriptions — with only the changed one swapped for its prior state
+            updatedMember._previousRelations = {
+                ...updatedMember._previousRelations,
+                stripeSubscriptions: {
+                    models: updatedMember.related('stripeSubscriptions').models.map((subscription) => {
+                        return subscription.id === subscriptionBeforeCancelFlagChange.id ? subscriptionBeforeCancelFlagChange : subscription;
+                    })
+                }
+            };
+        }
+
         const newMemberProductIds = memberProducts.map(product => product.id);
         const oldMemberProductIds = oldMemberProducts.map(product => product.id);
 

package/core/server/services/slack-notifications/slack-notifications.js

@@ -1,6 +1,6 @@
-const got = require('got').default;
 const validator = require('@tryghost/validator');
 const errors = require('@tryghost/errors');
+const externalRequest = require('../../lib/request-external');
 const ghostVersion = require('@tryghost/version');
 const moment = require('moment');
 
@@ -178,7 +178,7 @@ class SlackNotifications {
             };
         }
 
-        return await got.post(url, requestOptions);
+        return await externalRequest.post(url, requestOptions);
     }
 
     /**

package/core/server/services/slack-ping/index.js

@@ -12,7 +12,7 @@ class SlackPingServiceWrapper {
         const { blogIcon } = require('../../lib/image');
         const events = require('../../lib/common/events');
         const logging = require('@tryghost/logging');
-        const request = require('@tryghost/request');
+        const request = require('../../lib/request-external');
         const settingsCache = require('../../../shared/settings-cache');
         const urlService = require('../url');
         const urlUtils = require('../../../shared/url-utils').default;

package/core/server/services/slack-ping/index.ts

@@ -13,7 +13,7 @@ class SlackPingServiceWrapper {
         const {blogIcon} = require('../../lib/image');
         const events = require('../../lib/common/events');
         const logging = require('@tryghost/logging');
-        const request = require('@tryghost/request');
+        const request = require('../../lib/request-external');
         const settingsCache = require('../../../shared/settings-cache');
         const urlService = require('../url');
         const urlUtils = require('../../../shared/url-utils').default;

package/core/server/services/slack-ping/slack-ping-service.js

@@ -156,6 +156,7 @@ class SlackPingService {
                 };
             }
             return this.request(slackSettings.url, {
+                method: 'POST',
                 body: JSON.stringify(slackData),
                 headers: {
                     'Content-type': 'application/json'

package/core/server/services/slack-ping/slack-ping-service.ts

@@ -232,6 +232,7 @@ export class SlackPingService {
             }
 
             return this.request(slackSettings.url, {
+                method: 'POST',
                 body: JSON.stringify(slackData),
                 headers: {
                     'Content-type': 'application/json'

package/core/server/services/stats/members-stats-service.js

@@ -111,13 +111,6 @@ class MembersStatsService {
         const startDateMoment = moment.utc(startDate).startOf('day');
         const endDateMoment = moment.utc(today).startOf('day');
         
-        // Create a map of events by date for fast lookup
-        const eventsMap = new Map();
-        rows.forEach((row) => {
-            const date = moment(row.date).format('YYYY-MM-DD');
-            eventsMap.set(date, row);
-        });
-
         // Sort rows chronologically to calculate historical totals
         rows.sort((a, b) => moment(a.date).valueOf() - moment(b.date).valueOf());