ghost 5.110.4 → 5.112.0

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

@@ -1,7 +1,7 @@
 const _ = require('lodash');
 const debug = require('@tryghost/debug')('services:url:resources');
 const DomainEvents = require('@tryghost/domain-events');
-const {URLResourceUpdatedEvent} = require('@tryghost/dynamic-routing-events');
+const URLResourceUpdatedEvent = require('../../../shared/events/URLResourceUpdatedEvent');
 const Resource = require('./Resource');
 const config = require('../../../shared/config');
 const models = require('../../models');
@@ -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);
     }
 
     /**

package/core/shared/config/defaults.json

@@ -127,7 +127,8 @@
             "lifetime": 3600,
             "freeRetries": 10
         },
-        "blocked_email_domains": []
+        "blocked_email_domains": [],
+        "captcha_enabled": false
     },
     "caching": {
         "301": {

package/core/shared/events/URLResourceUpdatedEvent.js

@@ -0,0 +1,33 @@
+module.exports = class URLResourceUpdatedEvent {
+    /**
+     * @readonly
+     * @type {Object}
+     */
+    data;
+
+    /**
+     * @readonly
+     * @type {Date}
+     */
+    timestamp;
+
+    /**
+     * @private
+     */
+    constructor({timestamp, ...data}) {
+        this.data = data;
+        this.timestamp = timestamp;
+    }
+
+    /**
+     *
+     * @param {Object} data URL Resource
+     * @returns
+     */
+    static create(data) {
+        return new URLResourceUpdatedEvent({
+            ...data,
+            timestamp: data.timestamp || new Date
+        });
+    }
+};

package/core/shared/settings-cache/public.js

@@ -48,5 +48,6 @@ module.exports = {
     default_email_address: 'default_email_address',
     support_email_address: 'support_email_address',
     editor_default_email_recipients: 'editor_default_email_recipients',
+    captcha_enabled: 'captcha_enabled',
     labs: 'labs'
 };