Fixed top sources not deduplicating free->paid conversions (#24570)

ref
https://linear.app/ghost/issue/ENG-2496/analytics-growth-top-sources-sources-free-members-is-not-showing
- in other places (post stats) we 'deduplicate' member counts where a
free signup also includes a paid conversion in the same time frame; this
was not handled in Sources
- added unit test coverage to describe cases/behavior

We've defined member attribution in the Analytics apps as only counting
a free signup if the user didn't also sign up as a paid member in the
same timeframe. This makes it a bit easier to reason about your total
member count when looking at the free/paid split.

Author: 9larsons

ghost/core/core/server/services/stats/ReferrersStatsService.js

@@ -250,52 +250,6 @@ class ReferrersStatsService {
         return rows;
     }
 
-    /**
-     * Fetch paid conversion sources with date range
-     * @param {string} startDate 
-     * @param {string} endDate 
-     * @returns {Promise<PaidConversionsCountStatDate[]>}
-     **/
-    async fetchPaidConversionSourcesWithRange(startDate, endDate) {
-        const knex = this.knex;
-        const startDateTime = moment.utc(startDate).startOf('day').format('YYYY-MM-DD HH:mm:ss');
-        const endDateTime = moment.utc(endDate).endOf('day').format('YYYY-MM-DD HH:mm:ss');
-        
-        const rows = await knex('members_subscription_created_events')
-            .select(knex.raw(`DATE(created_at) as date`))
-            .select(knex.raw(`COUNT(*) as paid_conversions`))
-            .select(knex.raw(`referrer_source as source`))
-            .where('created_at', '>=', startDateTime)
-            .where('created_at', '<=', endDateTime)
-            .groupBy('date', 'referrer_source')
-            .orderBy('date');
-
-        return rows;
-    }
-
-    /**
-     * Fetch signup sources with date range
-     * @param {string} startDate 
-     * @param {string} endDate 
-     * @returns {Promise<SignupCountStatDate[]>}
-     **/
-    async fetchSignupSourcesWithRange(startDate, endDate) {
-        const knex = this.knex;
-        const startDateTime = moment.utc(startDate).startOf('day').format('YYYY-MM-DD HH:mm:ss');
-        const endDateTime = moment.utc(endDate).endOf('day').format('YYYY-MM-DD HH:mm:ss');
-        
-        const rows = await knex('members_created_events')
-            .select(knex.raw(`DATE(created_at) as date`))
-            .select(knex.raw(`COUNT(*) as signups`))
-            .select(knex.raw(`referrer_source as source`))
-            .where('created_at', '>=', startDateTime)
-            .where('created_at', '<=', endDateTime)
-            .groupBy('date', 'referrer_source')
-            .orderBy('date');
-
-        return rows;
-    }
-
     /**
      * Fetch MRR sources with date range
      * @param {string} startDate 
@@ -326,6 +280,76 @@ class ReferrersStatsService {
         return rows;
     }
 
+    /**
+     * Fetch deduplicated member counts by source with date range
+     * Returns both free signups (excluding those who converted) and paid conversions
+     * @param {string} startDate 
+     * @param {string} endDate 
+     * @returns {Promise<{source: string, signups: number, paid_conversions: number}[]>}
+     **/
+    async fetchMemberCountsBySource(startDate, endDate) {
+        const knex = this.knex;
+        const startDateTime = moment.utc(startDate).startOf('day').format('YYYY-MM-DD HH:mm:ss');
+        const endDateTime = moment.utc(endDate).endOf('day').format('YYYY-MM-DD HH:mm:ss');
+        
+        // Query 1: Free members who haven't converted to paid within the same time window
+        const freeSignupsQuery = knex('members_created_events as mce')
+            .select('mce.referrer_source as source')
+            .select(knex.raw('COUNT(DISTINCT mce.member_id) as signups'))
+            .leftJoin('members_subscription_created_events as msce', function () {
+                this.on('mce.member_id', '=', 'msce.member_id')
+                    // Only join if the conversion happened within the same time window
+                    .andOn('msce.created_at', '>=', knex.raw('?', [startDateTime]))
+                    .andOn('msce.created_at', '<=', knex.raw('?', [endDateTime]));
+            })
+            .where('mce.created_at', '>=', startDateTime)
+            .where('mce.created_at', '<=', endDateTime)
+            .whereNull('msce.id')
+            .groupBy('mce.referrer_source');
+
+        // Query 2: Paid conversions
+        const paidConversionsQuery = knex('members_subscription_created_events as msce')
+            .select('msce.referrer_source as source')
+            .select(knex.raw('COUNT(DISTINCT msce.member_id) as paid_conversions'))
+            .where('msce.created_at', '>=', startDateTime)
+            .where('msce.created_at', '<=', endDateTime)
+            .groupBy('msce.referrer_source');
+
+        // Execute both queries in parallel
+        const [freeResults, paidResults] = await Promise.all([
+            freeSignupsQuery,
+            paidConversionsQuery
+        ]);
+
+        // Combine results by source
+        const sourceMap = new Map();
+        
+        // Add free signups
+        freeResults.forEach((row) => {
+            sourceMap.set(row.source, {
+                source: row.source,
+                signups: parseInt(row.signups) || 0,
+                paid_conversions: 0
+            });
+        });
+        
+        // Add paid conversions
+        paidResults.forEach((row) => {
+            const existing = sourceMap.get(row.source);
+            if (existing) {
+                existing.paid_conversions = parseInt(row.paid_conversions) || 0;
+            } else {
+                sourceMap.set(row.source, {
+                    source: row.source,
+                    signups: 0,
+                    paid_conversions: parseInt(row.paid_conversions) || 0
+                });
+            }
+        });
+
+        return Array.from(sourceMap.values());
+    }
+
     /**
      * Return aggregated attribution sources for a date range, grouped by source only (not by date)
      * This is used for "Top Sources" tables that need server-side sorting
@@ -336,35 +360,47 @@ class ReferrersStatsService {
      * @returns {Promise<{data: AttributionCountStatWithMrr[], meta: {}}>}
      */
     async getTopSourcesWithRange(startDate, endDate, orderBy = 'signups desc', limit = 50) {
-        const paidConversionEntries = await this.fetchPaidConversionSourcesWithRange(startDate, endDate);
-        const signupEntries = await this.fetchSignupSourcesWithRange(startDate, endDate);
-        const mrrEntries = await this.fetchMrrSourcesWithRange(startDate, endDate);
+        // Get deduplicated member counts and MRR data in parallel
+        const [memberCounts, mrrEntries] = await Promise.all([
+            this.fetchMemberCountsBySource(startDate, endDate),
+            this.fetchMrrSourcesWithRange(startDate, endDate)
+        ]);
 
         // Aggregate by source (not by date + source)
         const sourceMap = new Map();
 
-        // Add signup data
-        signupEntries.forEach((entry) => {
-            const source = normalizeSource(entry.source);
-            const existing = sourceMap.get(source) || {source, signups: 0, paid_conversions: 0, mrr: 0};
-            existing.signups += entry.signups;
-            sourceMap.set(source, existing);
-        });
-
-        // Add paid conversion data
-        paidConversionEntries.forEach((entry) => {
+        // Add member counts (both signups and paid conversions)
+        memberCounts.forEach((entry) => {
             const source = normalizeSource(entry.source);
-            const existing = sourceMap.get(source) || {source, signups: 0, paid_conversions: 0, mrr: 0};
-            existing.paid_conversions += entry.paid_conversions;
-            sourceMap.set(source, existing);
+            const existing = sourceMap.get(source);
+            if (existing) {
+                // Aggregate if the normalized source already exists (e.g., multiple null/empty values)
+                existing.signups += entry.signups;
+                existing.paid_conversions += entry.paid_conversions;
+            } else {
+                sourceMap.set(source, {
+                    source,
+                    signups: entry.signups,
+                    paid_conversions: entry.paid_conversions,
+                    mrr: 0
+                });
+            }
         });
 
         // Add MRR data
         mrrEntries.forEach((entry) => {
             const source = normalizeSource(entry.source);
-            const existing = sourceMap.get(source) || {source, signups: 0, paid_conversions: 0, mrr: 0};
-            existing.mrr += entry.mrr;
-            sourceMap.set(source, existing);
+            const existing = sourceMap.get(source);
+            if (existing) {
+                existing.mrr += entry.mrr;
+            } else {
+                sourceMap.set(source, {
+                    source,
+                    signups: 0,
+                    paid_conversions: 0,
+                    mrr: entry.mrr
+                });
+            }
         });
 
         // Convert to array and sort