ghost 5.111.0 → 5.112.0

package/core/server/services/stats/MrrStatsService.js

@@ -0,0 +1,161 @@
+const moment = require('moment');
+
+class MrrStatsService {
+    /**
+     * @param {object} deps
+     * @param {import('knex').Knex} deps.knex
+     **/
+    constructor({knex}) {
+        this.knex = knex;
+    }
+
+    /**
+     * Get the current total MRR, grouped by currency (ascending order)
+     * @returns {Promise<MrrByCurrency[]>}
+     */
+    async getCurrentMrr() {
+        const knex = this.knex;
+        const rows = await knex('members_stripe_customers_subscriptions')
+            .select(knex.raw(`plan_currency as currency`))
+            .select(knex.raw(`SUM(mrr) AS mrr`))
+            .groupBy('plan_currency')
+            .orderBy('currency');
+
+        if (rows.length === 0) {
+            // Add a USD placeholder to always have at least one currency
+            rows.push({
+                currency: 'usd',
+                mrr: 0
+            });
+        }
+
+        return rows;
+    }
+
+    /**
+     * Get the MRR deltas for all days (from old to new), grouped by currency (ascending alphabetically)
+     * @returns {Promise<MrrDelta[]>} The deltas sorted from new to old
+     */
+    async fetchAllDeltas() {
+        const knex = this.knex;
+        const ninetyDaysAgo = moment.utc().subtract(90, 'days').startOf('day').utc().format('YYYY-MM-DD HH:mm:ss');
+        const rows = await knex('members_paid_subscription_events')
+            .select('currency')
+            // In SQLite, DATE(created_at) would map to a string value, while DATE(created_at) would map to a JSDate object in MySQL
+            // That is why we need the cast here (to have some consistency)
+            .select(knex.raw('CAST(DATE(created_at) as CHAR) as date'))
+            .select(knex.raw(`SUM(mrr_delta) as delta`))
+            .where('created_at', '>=', ninetyDaysAgo)
+            .groupByRaw('CAST(DATE(created_at) as CHAR), currency');
+        return rows;
+    }
+
+    /**
+     * Returns a list of the MRR history for each day and currency, including the current MRR per currency as meta data.
+     * The respons is in ascending date order, and currencies for the same date are always in ascending order.
+     * @returns {Promise<MrrHistory>}
+     */
+    async getHistory() {
+        // Fetch current total amounts and start counting from there
+        const totals = await this.getCurrentMrr();
+
+        const rows = await this.fetchAllDeltas();
+
+        rows.sort((rowA, rowB) => {
+            const dateA = new Date(rowA.date);
+            const dateB = new Date(rowB.date);
+        
+            return dateA - dateB || rowA.currency.localeCompare(rowB.currency);
+        });
+
+        // Get today in UTC (default timezone)
+        const today = moment().format('YYYY-MM-DD');
+
+        const results = [];
+
+        // Create a map of the totals by currency for fast lookup and editing
+
+        /** @type {Object.<string, number>}*/
+        const currentTotals = {};
+        for (const total of totals) {
+            currentTotals[total.currency] = total.mrr;
+        }
+
+        // Loop in reverse order (needed to have correct sorted result)
+        for (let i = rows.length - 1; i >= 0; i -= 1) {
+            const row = rows[i];
+
+            if (currentTotals[row.currency] === undefined) {
+                // Skip unexpected currencies that are not in the totals
+                continue;
+            }
+
+            // Convert JSDates to YYYY-MM-DD (in UTC)
+            const date = moment(row.date).format('YYYY-MM-DD');
+
+            if (date > today) {
+                // Skip results that are in the future for some reason
+                continue;
+            }
+
+            results.unshift({
+                date,
+                mrr: Math.max(0, currentTotals[row.currency]),
+                currency: row.currency
+            });
+
+            currentTotals[row.currency] -= row.delta;
+        }
+
+        // Now also add the oldest days we have left over and do not have deltas
+        const oldestDate = rows.length > 0 ? moment(rows[0].date).add(-1, 'days').format('YYYY-MM-DD') : today;
+
+        // Note that we also need to loop the totals in reverse order because we need to unshift
+        for (let i = totals.length - 1; i >= 0; i -= 1) {
+            const total = totals[i];
+            results.unshift({
+                date: oldestDate,
+                mrr: Math.max(0, currentTotals[total.currency]),
+                currency: total.currency
+            });
+        }
+
+        return {
+            data: results,
+            meta: {
+                totals
+            }
+        };
+    }
+}
+
+module.exports = MrrStatsService;
+
+/**
+ * @typedef MrrByCurrency
+ * @type {Object}
+ * @property {number} mrr
+ * @property {string} currency
+ */
+
+/**
+ * @typedef MrrDelta
+ * @type {Object}
+ * @property {Date} date
+ * @property {string} currency
+ * @property {number} delta MRR change on this day
+ */
+
+/**
+ * @typedef {Object} MrrRecord
+ * @property {string} date In YYYY-MM-DD format
+ * @property {string} currency
+ * @property {number} mrr MRR on this day
+ */
+
+/**
+ * @typedef {Object} MrrHistory
+ * @property {MrrRecord[]} data List of the total members by status for each day, including the paid deltas paid_subscribed and paid_canceled
+ * @property {Object} meta
+ * @property {MrrByCurrency[]} meta.totals
+ */

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

@@ -0,0 +1,164 @@
+const moment = require('moment');
+
+class ReferrersStatsService {
+    /**
+     * @param {object} deps
+     * @param {import('knex').Knex} deps.knex
+     **/
+    constructor({knex}) {
+        this.knex = knex;
+    }
+
+    /**
+     * Return a list of all the attribution sources for a given post, with their signup and conversion counts
+     * @param {string} postId
+     * @returns {Promise<AttributionCountStat[]>}
+     */
+    async getForPost(postId) {
+        const knex = this.knex;
+        const signupRows = await knex('members_created_events')
+            .select('referrer_source')
+            .select(knex.raw('COUNT(id) AS total'))
+            .where('attribution_id', postId)
+            .where('attribution_type', 'post')
+            .groupBy('referrer_source');
+
+        const conversionRows = await knex('members_subscription_created_events')
+            .select('referrer_source')
+            .select(knex.raw('COUNT(id) AS total'))
+            .where('attribution_id', postId)
+            .where('attribution_type', 'post')
+            .groupBy('referrer_source');
+
+        // Stitch them toghether, grouping them by source
+
+        const map = new Map();
+        for (const row of signupRows) {
+            map.set(row.referrer_source, {
+                source: row.referrer_source,
+                signups: row.total,
+                paid_conversions: 0
+            });
+        }
+
+        for (const row of conversionRows) {
+            const existing = map.get(row.referrer_source) ?? {
+                source: row.referrer_source,
+                signups: 0,
+                paid_conversions: 0
+            };
+            existing.paid_conversions = row.total;
+            map.set(row.referrer_source, existing);
+        }
+
+        return [...map.values()].sort((a, b) => b.paid_conversions - a.paid_conversions);
+    }
+
+    /**
+     * Return a list of all the attribution sources, with their signup and conversion counts on each date
+     * @returns {Promise<{data: AttributionCountStat[], meta: {}}>}
+     */
+    async getReferrersHistory() {
+        const paidConversionEntries = await this.fetchAllPaidConversionSources();
+        const signupEntries = await this.fetchAllSignupSources();
+
+        const allEntries = signupEntries.map((entry) => {
+            return {
+                ...entry,
+                paid_conversions: 0,
+                date: moment(entry.date).format('YYYY-MM-DD')
+            };
+        });
+
+        paidConversionEntries.forEach((entry) => {
+            const entryDate = moment(entry.date).format('YYYY-MM-DD');
+            const existingEntry = allEntries.find(e => e.source === entry.source && e.date === entryDate);
+
+            if (existingEntry) {
+                existingEntry.paid_conversions = entry.paid_conversions;
+            } else {
+                allEntries.push({
+                    ...entry,
+                    signups: 0,
+                    date: entryDate
+                });
+            }
+        });
+
+        // sort allEntries in date ascending format
+        allEntries.sort((a, b) => {
+            return moment(a.date).diff(moment(b.date));
+        });
+
+        return {
+            data: allEntries,
+            meta: {}
+        };
+    }
+
+    /**
+     * @returns {Promise<PaidConversionsCountStatDate[]>}
+     **/
+    async fetchAllPaidConversionSources() {
+        const knex = this.knex;
+        const ninetyDaysAgo = moment.utc().subtract(90, 'days').startOf('day').utc().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', '>=', ninetyDaysAgo)
+            .groupBy('date', 'referrer_source')
+            .orderBy('date');
+
+        return rows;
+    }
+
+    /**
+     * @returns {Promise<SignupCountStatDate[]>}
+     **/
+    async fetchAllSignupSources() {
+        const knex = this.knex;
+        const ninetyDaysAgo = moment.utc().subtract(90, 'days').startOf('day').utc().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', '>=', ninetyDaysAgo)
+            .groupBy('date', 'referrer_source')
+            .orderBy('date');
+
+        return rows;
+    }
+}
+
+module.exports = ReferrersStatsService;
+
+/**
+ * @typedef AttributionCountStat
+ * @type {Object}
+ * @property {string} source Attribution Source
+ * @property {number} signups Total free members signed up for this source
+ * @property {number} paid_conversions Total paid conversions for this source
+ */
+
+/**
+ * @typedef AttributionCountStatDate
+ * @type {AttributionCountStat}
+ * @property {string} date The date (YYYY-MM-DD) on which these counts were recorded
+ */
+
+/**
+ * @typedef {object} SignupCountStatDate
+ * @type {Object}
+ * @property {string} source Attribution Source
+ * @property {number} signups Total free members signed up for this source
+ * @property {string} date The date (YYYY-MM-DD) on which these counts were recorded
+ **/
+
+/**
+ * @typedef {object} PaidConversionsCountStatDate
+ * @type {Object}
+ * @property {string} source Attribution Source
+ * @property {number} paid_conversions Total paid conversions for this source
+ * @property {string} date The date (YYYY-MM-DD) on which these counts were recorded
+ **/

package/core/server/services/stats/StatsService.js

@@ -0,0 +1,63 @@
+const MRRService = require('./MrrStatsService');
+const MembersService = require('./MembersStatsService');
+const SubscriptionStatsService = require('./SubscriptionStatsService');
+const ReferrersStatsService = require('./ReferrersStatsService');
+
+class StatsService {
+    /**
+     * @param {object} deps
+     * @param {MRRService} deps.mrr
+     * @param {MembersService} deps.members
+     * @param {SubscriptionStatsService} deps.subscriptions
+     * @param {ReferrersStatsService} deps.referrers
+     **/
+    constructor(deps) {
+        this.mrr = deps.mrr;
+        this.members = deps.members;
+        this.subscriptions = deps.subscriptions;
+        this.referrers = deps.referrers;
+    }
+
+    async getMRRHistory() {
+        return this.mrr.getHistory();
+    }
+
+    async getMemberCountHistory() {
+        return this.members.getCountHistory();
+    }
+
+    async getSubscriptionCountHistory() {
+        return this.subscriptions.getSubscriptionHistory();
+    }
+
+    async getReferrersHistory() {
+        return this.referrers.getReferrersHistory();
+    }
+
+    /**
+     * @param {string} postId
+     */
+    async getPostReferrers(postId) {
+        return {
+            data: await this.referrers.getForPost(postId),
+            meta: {}
+        };
+    }
+
+    /**
+     * @param {object} deps
+     * @param {import('knex').Knex} deps.knex
+     *
+     * @returns {StatsService}
+     **/
+    static create(deps) {
+        return new StatsService({
+            mrr: new MRRService(deps),
+            members: new MembersService(deps),
+            subscriptions: new SubscriptionStatsService(deps),
+            referrers: new ReferrersStatsService(deps)
+        });
+    }
+}
+
+module.exports = StatsService;

package/core/server/services/stats/SubscriptionStatsService.js

@@ -0,0 +1,180 @@
+const moment = require('moment');
+
+class SubscriptionStatsService {
+    /**
+     * @param {object} deps
+     * @param {import('knex').Knex} deps.knex*/
+    constructor({knex}) {
+        this.knex = knex;
+    }
+
+    /**
+     * @returns {Promise<{data: SubscriptionHistoryEntry[]}>}
+     **/
+    async getSubscriptionHistory() {
+        const subscriptionDeltaEntries = await this.fetchAllSubscriptionDeltas();
+        const counts = await this.fetchSubscriptionCounts();
+
+        /** @type {Object.<string, Object.<string, number>>} */
+        const countData = {};
+        counts.forEach((count) => {
+            if (!countData[count.tier]) {
+                countData[count.tier] = {};
+            }
+            countData[count.tier][count.cadence] = count.count;
+        });
+
+        /** @type {SubscriptionHistoryEntry[]} */
+        let subscriptionHistoryEntries = [];
+
+        /** @type {string[]} */
+        let cadences = [];
+        /** @type {string[]} */
+        let tiers = [];
+
+        for (let index = subscriptionDeltaEntries.length - 1; index >= 0; index -= 1) {
+            const entry = subscriptionDeltaEntries[index];
+            if (!countData[entry.tier]) {
+                countData[entry.tier] = {};
+            }
+            if (!countData[entry.tier][entry.cadence]) {
+                countData[entry.tier][entry.cadence] = 0;
+            }
+
+            subscriptionHistoryEntries.unshift({
+                ...entry,
+                date: moment(entry.date).format('YYYY-MM-DD'),
+                count: countData[entry.tier][entry.cadence]
+            });
+
+            countData[entry.tier][entry.cadence] += entry.negative_delta;
+            countData[entry.tier][entry.cadence] -= entry.positive_delta;
+
+            if (!cadences.includes(entry.cadence)) {
+                cadences.push(entry.cadence);
+            }
+            if (!tiers.includes(entry.tier)) {
+                tiers.push(entry.tier);
+            }
+        }
+
+        return {
+            data: subscriptionHistoryEntries,
+            meta: {
+                cadences,
+                tiers,
+                totals: counts
+            }
+        };
+    }
+
+    /**
+     * @returns {Promise<SubscriptionDelta[]>}
+     **/
+    async fetchAllSubscriptionDeltas() {
+        const knex = this.knex;
+        const rows = await knex('members_paid_subscription_events')
+            .join('stripe_prices AS price', function () {
+                this.on('price.stripe_price_id', '=', 'members_paid_subscription_events.from_plan')
+                    .orOn('price.stripe_price_id', '=', 'members_paid_subscription_events.to_plan');
+            })
+            .join('stripe_products AS product', 'product.stripe_product_id', '=', 'price.stripe_product_id')
+            .join('products AS tier', 'tier.id', '=', 'product.product_id')
+            .leftJoin('stripe_prices AS from_price', 'from_price.stripe_price_id', '=', 'members_paid_subscription_events.from_plan')
+            .leftJoin('stripe_prices AS to_price', 'to_price.stripe_price_id', '=', 'members_paid_subscription_events.to_plan')
+            .select(knex.raw(`
+                DATE(members_paid_subscription_events.created_at) as date
+            `))
+            .select(knex.raw(`
+                tier.id as tier
+            `))
+            .select(knex.raw(`
+                price.interval as cadence
+            `))
+            .select(knex.raw(`SUM(
+                CASE
+                    WHEN members_paid_subscription_events.type IN ('created','reactivated','active') AND members_paid_subscription_events.mrr_delta != 0 THEN 1
+                    WHEN members_paid_subscription_events.type='updated' AND price.id = to_price.id THEN 1
+                    WHEN members_paid_subscription_events.type='updated' AND members_paid_subscription_events.from_plan = members_paid_subscription_events.to_plan AND members_paid_subscription_events.mrr_delta > 0 THEN 1
+                    ELSE 0
+                END
+            ) as positive_delta`))
+            .select(knex.raw(`SUM(
+                CASE
+                    WHEN members_paid_subscription_events.type IN ('canceled', 'expired','inactive') AND members_paid_subscription_events.mrr_delta != 0 THEN 1
+                    WHEN members_paid_subscription_events.type='updated' AND price.id = from_price.id THEN 1
+                    ELSE 0
+                END
+            ) as negative_delta`))
+            .select(knex.raw(`SUM(
+                CASE
+                    WHEN members_paid_subscription_events.type IN ('created','reactivated','active') AND members_paid_subscription_events.mrr_delta != 0 THEN 1
+                    WHEN members_paid_subscription_events.type='updated' AND members_paid_subscription_events.from_plan = members_paid_subscription_events.to_plan AND members_paid_subscription_events.mrr_delta > 0 THEN 1
+                    ELSE 0
+                END
+            ) as signups`))
+            .select(knex.raw(`SUM(
+                CASE
+                    WHEN members_paid_subscription_events.type IN ('canceled', 'expired','inactive') AND members_paid_subscription_events.mrr_delta != 0 THEN 1
+                    ELSE 0
+                END
+            ) as cancellations`))
+            .groupBy('date', 'tier', 'cadence')
+            .orderBy('date');
+
+        return rows;
+    }
+
+    /**
+      * Get the current total subscriptions grouped by Cadence and Tier
+      * @returns {Promise<SubscriptionCount[]>}
+      **/
+    async fetchSubscriptionCounts() {
+        const knex = this.knex;
+
+        const data = await knex('members_stripe_customers_subscriptions')
+            .select(knex.raw(`
+                  COUNT(members_stripe_customers_subscriptions.id) AS count,
+                  products.id AS tier,
+                  stripe_prices.interval AS cadence
+             `))
+            .join('stripe_prices', 'stripe_prices.stripe_price_id', '=', 'members_stripe_customers_subscriptions.stripe_price_id')
+            .join('stripe_products', 'stripe_products.stripe_product_id', '=', 'stripe_prices.stripe_product_id')
+            .join('products', 'products.id', '=', 'stripe_products.product_id')
+            .whereNot('members_stripe_customers_subscriptions.mrr', 0)
+            .groupBy('tier', 'cadence');
+
+        return data;
+    }
+}
+
+/** @typedef {object} SubscriptionCount
+  * @prop {string} tier
+  * @prop {string} cadence
+  * @prop {number} count
+  **/
+
+/**
+ * @typedef {object} SubscriptionDelta
+ * @prop {string} tier
+ * @prop {string} cadence
+ * @prop {string} date
+ * @prop {number} positive_delta
+ * @prop {number} negative_delta
+ * @prop {number} signups
+ * @prop {number} cancellations
+ **/
+
+/**
+ * @typedef {object} SubscriptionHistoryEntry
+ * @prop {string} tier
+ * @prop {string} cadence
+ * @prop {string} date
+ * @prop {number} positive_delta
+ * @prop {number} negative_delta
+ * @prop {number} signups
+ * @prop {number} cancellations
+ * @prop {number} count
+ **/
+
+module.exports = SubscriptionStatsService;

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

@@ -10,7 +10,7 @@ class StatsServiceWrapper {
             return;
         }
 
-        const StatsService = require('@tryghost/stats-service');
+        const StatsService = require('./StatsService');
         const db = require('../../data/db');
 
         this.api = StatsService.create({knex: db.knex});

package/core/server/services/url/Resources.js

@@ -446,7 +446,7 @@ class Resources {
      * @returns {Object}
      */
     getByIdAndType(type, id) {
-        return _.find(this.data[type], {data: {id: id}});
+        return this.data[type]?.find(r => r.data.id === id);
     }
 
     /**