ghost 5.9.4 → 5.11.0

package/core/server/models/label.js

@@ -13,6 +13,9 @@ Label = ghostBookshelf.Model.extend({
 
     tableName: 'labels',
 
+    actionsCollectCRUD: true,
+    actionsResourceType: 'label',
+
     emitChange: function emitChange(event, options) {
         const eventToTrigger = 'label' + '.' + event;
         ghostBookshelf.Model.prototype.emitChange.bind(this)(this, eventToTrigger, options);
@@ -62,24 +65,6 @@ Label = ghostBookshelf.Model.extend({
         const attrs = ghostBookshelf.Model.prototype.toJSON.call(this, options);
 
         return attrs;
-    },
-
-    getAction(event, options) {
-        const actor = this.getActor(options);
-
-        // @NOTE: we ignore internal updates (`options.context.internal`) for now
-        if (!actor) {
-            return;
-        }
-
-        // @TODO: implement context
-        return {
-            event: event,
-            resource_id: this.id || this.previous('id'),
-            resource_type: 'label',
-            actor_id: actor.id,
-            actor_type: actor.type
-        };
     }
 }, {
     orderDefaultOptions: function orderDefaultOptions() {

package/core/server/models/member-created-event.js

@@ -0,0 +1,26 @@
+const errors = require('@tryghost/errors');
+const ghostBookshelf = require('./base');
+
+const MemberCreatedEvent = ghostBookshelf.Model.extend({
+    tableName: 'members_created_events',
+
+    member() {
+        return this.belongsTo('Member', 'member_id', 'id');
+    },
+
+    attribution() {
+        return this.belongsTo('Post', 'attribution_id', 'id');
+    }
+}, {
+    async edit() {
+        throw new errors.IncorrectUsageError({message: 'Cannot edit MemberCreatedEvent'});
+    },
+
+    async destroy() {
+        throw new errors.IncorrectUsageError({message: 'Cannot destroy MemberCreatedEvent'});
+    }
+});
+
+module.exports = {
+    MemberCreatedEvent: ghostBookshelf.model('MemberCreatedEvent', MemberCreatedEvent)
+};

package/core/server/models/member.js

@@ -3,6 +3,7 @@ const uuid = require('uuid');
 const _ = require('lodash');
 const config = require('../../shared/config');
 const {gravatar} = require('../lib/image');
+const labs = require('../../shared/labs');
 
 const Member = ghostBookshelf.Model.extend({
     tableName: 'members',
@@ -39,6 +40,12 @@ const Member = ghostBookshelf.Model.extend({
         }, {
             key: 'newsletters',
             replacement: 'newsletters.slug'
+        }, {
+            key: 'signup',
+            replacement: 'signups.attribution_id'
+        }, {
+            key: 'conversion',
+            replacement: 'conversions.attribution_id'
         }];
     },
 
@@ -73,6 +80,18 @@ const Member = ghostBookshelf.Model.extend({
                 joinFrom: 'member_id',
                 joinTo: 'customer_id',
                 joinToForeign: 'customer_id'
+            },
+            signups: {
+                tableName: 'members_created_events',
+                tableNameAs: 'signups',
+                type: 'oneToOne',
+                joinFrom: 'member_id'
+            },
+            conversions: {
+                tableName: 'members_subscription_created_events',
+                tableNameAs: 'conversions',
+                type: 'oneToOne',
+                joinFrom: 'member_id'
             }
         };
     },
@@ -102,12 +121,16 @@ const Member = ghostBookshelf.Model.extend({
 
     products() {
         return this.belongsToMany('Product', 'members_products', 'member_id', 'product_id')
-            .withPivot('sort_order')
+            .withPivot('sort_order', 'expiry_at')
             .query('orderBy', 'sort_order', 'ASC')
             .query((qb) => {
                 // avoids bookshelf adding a `DISTINCT` to the query
                 // we know the result set will already be unique and DISTINCT hurts query performance
-                qb.columns('products.*');
+                if (labs.isSet('compExpiring')) {
+                    qb.columns('products.*', 'expiry_at');
+                } else {
+                    qb.columns('products.*');
+                }
             });
     },
 
@@ -155,6 +178,21 @@ const Member = ghostBookshelf.Model.extend({
         return this.hasMany('EmailRecipient', 'member_id', 'id');
     },
 
+    async updateTierExpiry(products = [], options = {}) {
+        if (!labs.isSet('compExpiring')) {
+            return;
+        }
+        for (const product of products) {
+            if (product?.expiry_at) {
+                const expiry = new Date(product.expiry_at);
+                const queryOptions = _.extend({}, options, {
+                    query: {where: {product_id: product.id}}
+                });
+                await this.products().updatePivot({expiry_at: expiry}, queryOptions);
+            }
+        }
+    },
+
     serialize(options) {
         const defaultSerializedObject = ghostBookshelf.Model.prototype.serialize.call(this, options);
 
@@ -344,7 +382,13 @@ const Member = ghostBookshelf.Model.extend({
                 return this.add(data, Object.assign({transacting}, unfilteredOptions));
             });
         }
-        return ghostBookshelf.Model.add.call(this, data, unfilteredOptions);
+
+        return ghostBookshelf.Model.add.call(this, data, unfilteredOptions).then(async (member) => {
+            if (data.products) {
+                await member.updateTierExpiry(data.products, _.pick(unfilteredOptions, 'transacting'));
+            }
+            return member;
+        });
     },
 
     edit(data, unfilteredOptions = {}) {
@@ -353,7 +397,13 @@ const Member = ghostBookshelf.Model.extend({
                 return this.edit(data, Object.assign({transacting}, unfilteredOptions));
             });
         }
-        return ghostBookshelf.Model.edit.call(this, data, unfilteredOptions);
+
+        return ghostBookshelf.Model.edit.call(this, data, unfilteredOptions).then(async (member) => {
+            if (data.products) {
+                await member.updateTierExpiry(data.products, _.pick(unfilteredOptions, 'transacting'));
+            }
+            return member;
+        });
     },
 
     destroy(unfilteredOptions = {}) {

package/core/server/models/offer.js

@@ -3,6 +3,9 @@ const ghostBookshelf = require('./base');
 const Offer = ghostBookshelf.Model.extend({
     tableName: 'offers',
 
+    actionsCollectCRUD: true,
+    actionsResourceType: 'offer',
+
     product() {
         return this.belongsTo('Product', 'product_id', 'id');
     }

package/core/server/models/post.js

@@ -38,6 +38,10 @@ Post = ghostBookshelf.Model.extend({
 
     tableName: 'posts',
 
+    actionsCollectCRUD: true,
+    actionsResourceType: 'post',
+    actionsExtraContext: ['type'],
+
     /**
      * @NOTE
      *
@@ -962,24 +966,6 @@ Post = ghostBookshelf.Model.extend({
 
         delete options.status;
         return filter;
-    },
-
-    getAction(event, options) {
-        const actor = this.getActor(options);
-
-        // @NOTE: we ignore internal updates (`options.context.internal`) for now
-        if (!actor) {
-            return;
-        }
-
-        // @TODO: implement context
-        return {
-            event: event,
-            resource_id: this.id || this.previous('id'),
-            resource_type: 'post',
-            actor_id: actor.id,
-            actor_type: actor.type
-        };
     }
 }, {
     allowedFormats: ['mobiledoc', 'html', 'plaintext'],
@@ -1262,6 +1248,27 @@ Post = ghostBookshelf.Model.extend({
         return Promise.reject(new errors.NoPermissionError({
             message: tpl(messages.notEnoughPermission)
         }));
+    },
+
+    countRelations() {
+        return {
+            signups(modelOrCollection) {
+                modelOrCollection.query('columns', 'posts.*', (qb) => {
+                    qb.count('members_created_events.id')
+                        .from('members_created_events')
+                        .whereRaw('posts.id = members_created_events.attribution_id')
+                        .as('count__signups');
+                });
+            },
+            conversions(modelOrCollection) {
+                modelOrCollection.query('columns', 'posts.*', (qb) => {
+                    qb.count('members_subscription_created_events.id')
+                        .from('members_subscription_created_events')
+                        .whereRaw('posts.id = members_subscription_created_events.attribution_id')
+                        .as('count__conversions');
+                });
+            }
+        };
     }
 });
 

package/core/server/models/product.js

@@ -4,6 +4,9 @@ const _ = require('lodash');
 const Product = ghostBookshelf.Model.extend({
     tableName: 'products',
 
+    actionsCollectCRUD: true,
+    actionsResourceType: 'product',
+
     defaults: {
         active: true,
         visibility: 'none',

package/core/server/models/settings.js

@@ -97,6 +97,10 @@ Settings = ghostBookshelf.Model.extend({
 
     tableName: 'settings',
 
+    actionsCollectCRUD: true,
+    actionsResourceType: 'setting',
+    actionsExtraContext: ['key', 'group'],
+
     emitChange: function emitChange(event, options) {
         const eventToTrigger = 'settings' + '.' + event;
         ghostBookshelf.Model.prototype.emitChange.bind(this)(this, eventToTrigger, options);

package/core/server/models/subscription-created-event.js

@@ -0,0 +1,30 @@
+const errors = require('@tryghost/errors');
+const ghostBookshelf = require('./base');
+
+const SubscriptionCreatedEvent = ghostBookshelf.Model.extend({
+    tableName: 'members_subscription_created_events',
+
+    member() {
+        return this.belongsTo('Member', 'member_id', 'id');
+    },
+
+    subscription() {
+        return this.belongsTo('StripeCustomerSubscription', 'subscription_id', 'id');
+    },
+
+    attribution() {
+        return this.belongsTo('Post', 'attribution_id', 'id');
+    }
+}, {
+    async edit() {
+        throw new errors.IncorrectUsageError({message: 'Cannot edit SubscriptionCreatedEvent'});
+    },
+
+    async destroy() {
+        throw new errors.IncorrectUsageError({message: 'Cannot destroy SubscriptionCreatedEvent'});
+    }
+});
+
+module.exports = {
+    SubscriptionCreatedEvent: ghostBookshelf.model('SubscriptionCreatedEvent', SubscriptionCreatedEvent)
+};

package/core/server/models/tag.js

@@ -14,6 +14,9 @@ Tag = ghostBookshelf.Model.extend({
 
     tableName: 'tags',
 
+    actionsCollectCRUD: true,
+    actionsResourceType: 'tag',
+
     defaults: function defaults() {
         return {
             visibility: 'public'
@@ -138,24 +141,6 @@ Tag = ghostBookshelf.Model.extend({
         return attrs;
     },
 
-    getAction(event, options) {
-        const actor = this.getActor(options);
-
-        // @NOTE: we ignore internal updates (`options.context.internal`) for now
-        if (!actor) {
-            return;
-        }
-
-        // @TODO: implement context
-        return {
-            event: event,
-            resource_id: this.id || this.previous('id'),
-            resource_type: 'tag',
-            actor_id: actor.id,
-            actor_type: actor.type
-        };
-    },
-
     defaultColumnsToFetch() {
         return ['id'];
     }

package/core/server/models/user.js

@@ -57,12 +57,18 @@ User = ghostBookshelf.Model.extend({
 
     tableName: 'users',
 
+    actionsCollectCRUD: true,
+    actionsResourceType: 'user',
+
     defaults: function defaults() {
         return {
             password: security.identifier.uid(50),
             visibility: 'public',
             status: 'active',
-            comment_notifications: true
+            comment_notifications: true,
+            free_member_signup_notification: true,
+            paid_subscription_started_notification: true,
+            paid_subscription_canceled_notification: false
         };
     },
 
@@ -363,24 +369,6 @@ User = ghostBookshelf.Model.extend({
         delete options.status;
 
         return filter;
-    },
-
-    getAction(event, options) {
-        const actor = this.getActor(options);
-
-        // @NOTE: we ignore internal updates (`options.context.internal`) for now
-        if (!actor) {
-            return;
-        }
-
-        // @TODO: implement context
-        return {
-            event: event,
-            resource_id: this.id || this.previous('id'),
-            resource_type: 'user',
-            actor_id: actor.id,
-            actor_type: actor.type
-        };
     }
 }, {
     orderDefaultOptions: function orderDefaultOptions() {

package/core/server/models/webhook.js

@@ -7,6 +7,9 @@ let Webhooks;
 Webhook = ghostBookshelf.Model.extend({
     tableName: 'webhooks',
 
+    actionsCollectCRUD: true,
+    actionsResourceType: 'webhook',
+
     defaults() {
         return {
             api_version: `v${ghostVersion.safe}`,

package/core/server/services/auth/api-key/admin.js

@@ -181,9 +181,6 @@ const authenticateWithToken = async (req, res, next, {token, JWT_OPTIONS}) => {
             );
 
             req.user = user;
-
-            next();
-            return;
         }
 
         // store the api key on the request for later checks and logging

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

@@ -144,9 +144,6 @@ function doReset(options, tokenParts, settingsAPI) {
             updatedUser.set('status', 'active');
             return updatedUser.save(options);
         })
-        .catch(errors.ValidationError, (err) => {
-            return Promise.reject(err);
-        })
         .catch((err) => {
             if (errors.utils.isGhostError(err)) {
                 return Promise.reject(err);

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

@@ -45,7 +45,7 @@ class CommentsServiceEmails {
                 accentColor: this.settingsCache.get('accent_color'),
                 fromEmail: this.notificationFromAddress,
                 toEmail: to,
-                staffUrl: `${this.urlUtils.getAdminUrl()}ghost/#/settings/staff/${author.get('slug')}`
+                staffUrl: this.urlUtils.urlJoin(this.urlUtils.urlFor('admin', true), '#', `/settings/staff/${author.get('slug')}`)
             };
 
             const {html, text} = await this.renderEmailTemplate('new-comment', templateData);
@@ -132,7 +132,7 @@ class CommentsServiceEmails {
             commentHtml: comment.get('html'),
             commentText: htmlToPlaintext.comment(comment.get('html')),
             commentDate: moment(comment.get('created_at')).tz(this.settingsCache.get('timezone')).format('D MMM YYYY'),
-            
+
             reporterName: reporter.name,
             reporterEmail: reporter.email,
             reporter: reporter.name ? `${reporter.name} (${reporter.email})` : reporter.email,
@@ -144,7 +144,7 @@ class CommentsServiceEmails {
             accentColor: this.settingsCache.get('accent_color'),
             fromEmail: this.notificationFromAddress,
             toEmail: to,
-            staffUrl: `${this.urlUtils.getAdminUrl()}ghost/#/settings/staff/${owner.get('slug')}`
+            staffUrl: this.urlUtils.urlJoin(this.urlUtils.urlFor('admin', true), '#', `/settings/staff/${owner.get('slug')}`)
         };
 
         const {html, text} = await this.renderEmailTemplate('report', templateData);

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

@@ -26,17 +26,19 @@ module.exports = class ExploreService {
         const totalMembers = await this.MembersService.stats.getTotalMembers();
         const mrrStats = await this.StatsService.getMRRHistory();
 
-        const {description, icon, title, url} = this.PublicConfigService.site;
+        const {description, icon, title, url, accent_color: accentColor, locale} = this.PublicConfigService.site;
 
         const exploreProperties = {
             version: ghostVersion.full,
-            totalMembers,
-            mrrStats,
+            total_members: totalMembers,
+            mrr_stats: mrrStats,
             site: {
                 description,
                 icon,
                 title,
-                url
+                url,
+                accent_color: accentColor,
+                locale
             },
             stripe: {
                 configured: this.StripeService.api.configured,
@@ -45,10 +47,10 @@ module.exports = class ExploreService {
         };
 
         const mostRecentlyPublishedPost = await this.PostsService.getMostRecentlyPublishedPost();
-        exploreProperties.mostRecentlyPublishedAt = mostRecentlyPublishedPost?.get('published_at') || null;
+        exploreProperties.most_recently_published_at = mostRecentlyPublishedPost?.get('published_at') || null;
 
         const owner = await this.UserModel.findOne({role: 'Owner', status: 'all'});
-        exploreProperties.ownerEmail = owner?.get('email') || null;
+        exploreProperties.owner_email = owner?.get('email') || null;
 
         return exploreProperties;
     }

package/core/server/services/member-attribution/index.js

@@ -0,0 +1,52 @@
+const urlService = require('../url');
+const labsService = require('../../../shared/labs');
+const DomainEvents = require('@tryghost/domain-events');
+const urlUtils = require('../../../shared/url-utils');
+
+class MemberAttributionServiceWrapper {
+    init() {
+        if (this.eventHandler) {
+            // Prevent creating duplicate DomainEvents subscribers
+            return;
+        }
+
+        // Wire up all the dependencies
+        const {MemberAttributionService, UrlTranslator, AttributionBuilder, EventHandler} = require('@tryghost/member-attribution');
+        const models = require('../../models');
+
+        const urlTranslator = new UrlTranslator({
+            urlService, 
+            urlUtils,
+            models: {
+                Post: models.Post, 
+                User: models.User, 
+                Tag: models.Tag
+            }
+        });
+
+        const attributionBuilder = new AttributionBuilder({urlTranslator});
+
+        // Expose the service
+        this.service = new MemberAttributionService({
+            models: {
+                MemberCreatedEvent: models.MemberCreatedEvent,
+                SubscriptionCreatedEvent: models.SubscriptionCreatedEvent
+            },
+            attributionBuilder,
+            labsService
+        });
+
+        // Listen for events and store them in the database
+        this.eventHandler = new EventHandler({
+            models: {
+                MemberCreatedEvent: models.MemberCreatedEvent,
+                SubscriptionCreatedEvent: models.SubscriptionCreatedEvent
+            }, 
+            DomainEvents, 
+            labsService
+        });
+        this.eventHandler.subscribe();
+    }
+}
+
+module.exports = new MemberAttributionServiceWrapper();

package/core/server/services/members/api.js

@@ -14,6 +14,7 @@ const urlUtils = require('../../../shared/url-utils');
 const labsService = require('../../../shared/labs');
 const offersService = require('../offers');
 const newslettersService = require('../newsletters');
+const memberAttributionService = require('../member-attribution');
 
 const MAGIC_LINK_TOKEN_VALIDITY = 24 * 60 * 60 * 1000;
 
@@ -195,7 +196,8 @@ function createApiInstance(config) {
         stripeAPIService: stripeService.api,
         offersAPI: offersService.api,
         labsService: labsService,
-        newslettersService: newslettersService
+        newslettersService: newslettersService,
+        memberAttributionService: memberAttributionService.service
     });
 
     return membersApiInstance;

package/core/server/services/members/jobs/clean-expired-comped.js

@@ -0,0 +1,105 @@
+const {parentPort} = require('worker_threads');
+const ObjectId = require('bson-objectid').default;
+const {chunk: chunkArray} = require('lodash');
+const debug = require('@tryghost/debug')('jobs:clean-expired-comped');
+const moment = require('moment');
+
+// recurring job to clean expired complimentary subscriptions
+
+// Exit early when cancelled to prevent stalling shutdown. No cleanup needed when cancelling as everything is idempotent and will pick up
+// where it left off on next run
+function cancel() {
+    if (parentPort) {
+        parentPort.postMessage('Expired complimentary subscriptions cleanup cancelled before completion');
+        parentPort.postMessage('cancelled');
+    } else {
+        setTimeout(() => {
+            process.exit(0);
+        }, 1000);
+    }
+}
+
+if (parentPort) {
+    parentPort.once('message', (message) => {
+        if (message === 'cancel') {
+            return cancel();
+        }
+    });
+}
+
+(async () => {
+    const cleanupStartDate = new Date();
+    const db = require('../../../data/db');
+    debug(`Starting cleanup of expired comp subscriptions`);
+    const expiredCompedRows = await db.knex('members_products')
+        .where('expiry_at', '<', moment.utc().startOf('day').toISOString())
+        .select('*');
+
+    let deletedExpiredSubs = 0;
+    let updatedMembers = 0;
+
+    // Run cleanup for expired comp subscriptions
+    // Removes expired comped entries from members_products table
+    // Updates affected members status to free from comped
+    // Adds member status event for going from comped to free
+    if (expiredCompedRows?.length) {
+        const rowIds = expiredCompedRows.map(d => d.id);
+        const memberIds = expiredCompedRows.map(d => d.member_id);
+
+        // Delete all expired comped rows
+        deletedExpiredSubs = await db.knex('members_products')
+            .whereIn('id', rowIds)
+            .del();
+
+        // fetch all comped members to update
+        const membersToUpdate = await db.knex('members')
+            .whereIn('id', memberIds)
+            .andWhere('status', 'comped');
+
+        const updateMemberIds = membersToUpdate.map(d => d.id);
+
+        // Update all comped members to free
+        updatedMembers = await db.knex('members')
+            .whereIn('id', updateMemberIds)
+            .update({
+                status: 'free'
+            });
+
+        const statusEvents = membersToUpdate.map((member) => {
+            const now = db.knex.raw('CURRENT_TIMESTAMP');
+
+            return {
+                id: ObjectId().toHexString(),
+                member_id: member.id,
+                from_status: member.status,
+                to_status: 'free',
+                created_at: now
+            };
+        });
+
+        // SQLite >= 3.32.0 can support 32766 host parameters
+        // each row uses 5 variables so ⌊32766/5⌋ = 6553
+        const chunkSize = 6553;
+
+        const chunks = chunkArray(statusEvents, chunkSize);
+
+        // Adds status event for members going comped->free
+        for (const chunk of chunks) {
+            await db.knex('members_status_events').insert(chunk);
+        }
+    }
+
+    let cleanupEndDate = new Date();
+
+    debug(`Removed ${deletedExpiredSubs} expired subscriptions, updated ${updatedMembers} members in ${cleanupEndDate.valueOf() - cleanupStartDate.valueOf()}ms`);
+
+    if (parentPort) {
+        parentPort.postMessage(`Removed ${deletedExpiredSubs} expired subscriptions, updated ${updatedMembers} members in ${cleanupEndDate.valueOf() - cleanupStartDate.valueOf()}ms`);
+        parentPort.postMessage('done');
+    } else {
+        // give the logging pipes time finish writing before exit
+        setTimeout(() => {
+            process.exit(0);
+        }, 1000);
+    }
+})();