ghost 4.44.0 → 4.46.1

package/core/server/data/migrations/versions/4.45/2022-04-20-11-25-add-newsletter-read-permission.js

@@ -0,0 +1,9 @@
+const {addPermissionWithRoles} = require('../../utils');
+
+module.exports = addPermissionWithRoles({
+    name: 'Read newsletters',
+    action: 'read',
+    object: 'newsletter'
+}, [
+    'Administrator'
+]);

package/core/server/data/migrations/versions/4.45/2022-04-21-02-55-add-notifications-key-entry-to-settings-table.js

@@ -0,0 +1,8 @@
+const {addSetting} = require('../../utils.js');
+
+module.exports = addSetting({
+    key: 'version_notifications',
+    value: '[]',
+    type: 'array',
+    group: 'core'
+});

package/core/server/data/migrations/versions/4.46/2022-04-13-12-00-add-created-at-newsletters.js

@@ -0,0 +1,6 @@
+const {createAddColumnMigration} = require('../../utils');
+
+module.exports = createAddColumnMigration('newsletters', 'created_at', {
+    type: 'dateTime',
+    nullable: true
+});

package/core/server/data/migrations/versions/4.46/2022-04-13-12-01-add-updated-at-newsletters.js

@@ -0,0 +1,6 @@
+const {createAddColumnMigration} = require('../../utils');
+
+module.exports = createAddColumnMigration('newsletters', 'updated_at', {
+    type: 'dateTime',
+    nullable: true
+});

package/core/server/data/migrations/versions/4.46/2022-04-13-12-02-fill-created-at-newsletters.js

@@ -0,0 +1,19 @@
+const logging = require('@tryghost/logging');
+
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        logging.info('Setting missing created_at values for existing newsletters');
+
+        const now = knex.raw('CURRENT_TIMESTAMP');
+        const updatedRows = await knex('newsletters')
+            .where('created_at', null)
+            .update('created_at', now);
+
+        logging.info(`Updated ${updatedRows} newsletters with created_at = now`);
+    },
+    async function down() {
+        // Not required: we would lose information here.
+    }
+);

package/core/server/data/migrations/versions/4.46/2022-04-13-12-03-drop-nullable-created-at-newsletters.js

@@ -0,0 +1,3 @@
+const {createDropNullableMigration} = require('../../utils');
+
+module.exports = createDropNullableMigration('newsletters', 'created_at');

package/core/server/data/migrations/versions/4.46/2022-04-13-12-08-newsletters-show-header-name.js

@@ -0,0 +1,7 @@
+const {createAddColumnMigration} = require('../../utils');
+
+module.exports = createAddColumnMigration('newsletters', 'show_header_name', {
+    type: 'boolean',
+    nullable: false,
+    defaultTo: true
+});

package/core/server/data/migrations/versions/4.46/2022-04-13-12-57-add-uuid-column-to-newsletters.js

@@ -0,0 +1,8 @@
+const {createAddColumnMigration} = require('../../utils');
+
+module.exports = createAddColumnMigration('newsletters', 'uuid', {
+    type: 'string',
+    maxlength: 36,
+    nullable: true,
+    unique: true
+});

package/core/server/data/migrations/versions/4.46/2022-04-13-12-58-fill-uuid-for-newsletters.js

@@ -0,0 +1,19 @@
+const logging = require('@tryghost/logging');
+const uuid = require('uuid');
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        const newslettersWithoutUUID = await knex.select('id').from('newsletters').whereNull('uuid');
+
+        logging.info(`Adding uuid field value to ${newslettersWithoutUUID.length} newsletters.`);
+
+        // eslint-disable-next-line no-restricted-syntax
+        for (const newsletter of newslettersWithoutUUID) {
+            await knex('newsletters').update('uuid', uuid.v4()).where('id', newsletter.id);
+        }
+    },
+    async function down() {
+        // Not required: we would lose information here.
+    }
+);

package/core/server/data/migrations/versions/4.46/2022-04-13-12-59-drop-nullable-uuid-newsletters.js

@@ -0,0 +1,3 @@
+const {createDropNullableMigration} = require('../../utils');
+
+module.exports = createDropNullableMigration('newsletters', 'uuid');

package/core/server/data/migrations/versions/4.46/2022-04-13-13-00-add-default-newsletter.js

@@ -0,0 +1,92 @@
+const ObjectId = require('bson-objectid');
+const uuid = require('uuid');
+const logging = require('@tryghost/logging');
+const startsWith = require('lodash/startsWith');
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        // This uses the default settings from core/server/data/schema/default-settings/default-settings.json
+        const newsletter = {
+            id: (new ObjectId()).toHexString(),
+            uuid: uuid.v4(),
+            name: 'Ghost',
+            description: '',
+            slug: 'default-newsletter',
+            sender_name: null,
+            sender_email: null,
+            sender_reply_to: 'newsletter',
+            status: 'active',
+            visibility: 'members',
+            subscribe_on_signup: true,
+            sort_order: 0,
+            body_font_category: 'sans_serif',
+            footer_content: '',
+            header_image: null,
+            show_badge: true,
+            show_feature_image: true,
+            show_header_icon: true,
+            show_header_title: true,
+            show_header_name: false,
+            title_alignment: 'center',
+            title_font_category: 'sans_serif',
+            created_at: knex.raw('CURRENT_TIMESTAMP')
+        };
+
+        // Make sure the newsletter table is empty
+        const newsletters = await knex('newsletters').count('*', {as: 'total'});
+
+        if (newsletters[0].total !== 0) {
+            logging.warn('Skipping adding the default newsletter - There is already at least one newsletter');
+            return;
+        }
+
+        // Get all settings in one query
+        const settings = await knex('settings')
+            .whereIn('key', [
+                'title',
+                'description',
+                'newsletter_body_font_category',
+                'newsletter_footer_content',
+                'newsletter_header_image',
+                'newsletter_show_badge',
+                'newsletter_show_feature_image',
+                'newsletter_show_header_icon',
+                'newsletter_show_header_title',
+                'newsletter_title_alignment',
+                'newsletter_title_font_category'
+            ])
+            .select(['key', 'value']);
+
+        // eslint-disable-next-line no-restricted-syntax
+        for (let {key, value} of settings) {
+            // Use site title for the newsletter name
+            if (key === 'title') {
+                key = 'name';
+            }
+            // Settings have a `newsletter_` prefix which isn't present on the newsletters table
+            if (startsWith(key, 'newsletter_')) {
+                key = key.slice(11);
+            }
+
+            if (value === null && ['name', 'body_font_category', 'show_badge', 'show_feature_image', 'show_header_icon', 'show_header_title', 'title_alignment', 'title_font_category'].includes(key)) {
+                // Prevent setting null to non-nullable columns
+                // Default to defaults above in that case
+                continue;
+            }
+
+            if (typeof newsletter[key] === 'boolean') {
+                newsletter[key] = value === 'true';
+            } else {
+                newsletter[key] = value;
+            }
+        }
+
+        logging.info('Adding the default newsletter');
+        await knex('newsletters').insert(newsletter);
+    },
+    async function down(knex) {
+        logging.info(`Removing newsletters`);
+        await knex('newsletters').delete();
+    }
+);

package/core/server/data/migrations/versions/4.46/2022-04-20-08-39-map-subscribers-to-default-newsletter.js

@@ -0,0 +1,66 @@
+const logging = require('@tryghost/logging');
+const ObjectID = require('bson-objectid');
+
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        logging.info('Adding existing subscribers to default newsletter');
+
+        const newsletter = await knex('newsletters')
+            .orderBy('sort_order', 'asc')
+            .orderBy('created_at', 'asc')
+            .first('id', 'name');
+
+        if (!newsletter) {
+            logging.info(`Default newsletter not found - skipping`);
+            return;
+        }
+
+        // This is at the start of the up() instead of at the end of the down()
+        // to maintain idempotency
+        logging.info('Removing existing newsletter subscriptions');
+        await knex('members_newsletters').delete();
+
+        logging.info(`Subscribing members to newsletter '${newsletter.name}'`);
+
+        const memberIds = await knex('members')
+            .where({subscribed: true})
+            .pluck('id');
+
+        if (!memberIds.length) {
+            logging.info(`No members to subscribe - skipping`);
+            return;
+        }
+
+        logging.info(`Found ${memberIds.length} members to subscribe`);
+
+        const pivotRows = memberIds.map((memberId) => {
+            return {
+                id: ObjectID().toHexString(),
+                member_id: memberId,
+                newsletter_id: newsletter.id
+            };
+        });
+
+        await knex.batchInsert('members_newsletters', pivotRows);
+    },
+    async function down(knex) {
+        logging.info('Syncing subscriptions from newsletters -> members.subscribed');
+        await knex('members')
+            .whereIn('id', function () {
+                this.select('member_id').from('members_newsletters');
+            })
+            .update({
+                subscribed: true
+            });
+        logging.info('Syncing unsubscribes from newsletters -> members.subscribed');
+        await knex('members')
+            .whereNotIn('id', function () {
+                this.select('member_id').from('members_newsletters');
+            })
+            .update({
+                subscribed: false
+            });
+    }
+);

package/core/server/data/migrations/versions/4.46/2022-04-22-07-43-add-newsletter-id-to-subscribe-events.js

@@ -0,0 +1,9 @@
+const {createAddColumnMigration} = require('../../utils');
+
+module.exports = createAddColumnMigration('members_subscribe_events', 'newsletter_id', {
+    type: 'string', 
+    maxlength: 24,
+    nullable: true,
+    references: 'newsletters.id', 
+    cascadeDelete: false
+});

package/core/server/data/migrations/versions/4.46/2022-04-27-07-59-set-newsletter-id-subscribe-events.js

@@ -0,0 +1,31 @@
+const logging = require('@tryghost/logging');
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        // Get the default newsletter
+        const newsletter = await knex('newsletters')
+            .where('status', 'active')
+            .orderBy('sort_order', 'asc')
+            .orderBy('created_at', 'asc')
+            .orderBy('id', 'asc')
+            .first('id');
+
+        if (!newsletter) {
+            logging.error(`Default newsletter not found - skipping`);
+            return;
+        }
+
+        // Set subscribe events
+        const updatedRows = await knex('members_subscribe_events')
+            .update({
+                newsletter_id: newsletter.id
+            })
+            .where('newsletter_id', null);
+
+        logging.info(`Updated ${updatedRows} members_subscribe_events with default newsletter id`);
+    },
+    async function down() {
+        // Not required
+    }
+);

package/core/server/data/schema/commands.js

@@ -59,6 +59,18 @@ function addTableColumn(tableName, table, columnName, columnSpec = schema[tableN
     }
 }
 
+function setNullable(tableName, column, transaction = db.knex) {
+    return transaction.schema.table(tableName, function (table) {
+        table.setNullable(column);
+    });
+}
+
+function dropNullable(tableName, column, transaction = db.knex) {
+    return transaction.schema.table(tableName, function (table) {
+        table.dropNullable(column);
+    });
+}
+
 function addColumn(tableName, column, transaction = db.knex, columnSpec) {
     return transaction.schema.table(tableName, function (table) {
         addTableColumn(tableName, table, column, columnSpec);
@@ -412,6 +424,8 @@ module.exports = {
     dropForeign: dropForeign,
     addColumn: addColumn,
     dropColumn: dropColumn,
+    setNullable: setNullable,
+    dropNullable: dropNullable,
     getColumns: getColumns,
     createColumnMigration,
     // NOTE: below are exposed for testing purposes only

package/core/server/data/schema/default-settings/default-settings.json

@@ -16,6 +16,10 @@
             "defaultValue": "[]",
             "type": "array"
         },
+        "version_notifications": {
+            "defaultValue": "[]",
+            "type": "array"
+        },
         "session_secret": {
             "defaultValue": null,
             "type": "string"

package/core/server/data/schema/fixtures/fixtures.json

@@ -24,7 +24,8 @@
             "entries": [
                 {
                     "name":             "Default Newsletter",
-                    "slug":             "default-newsletter"
+                    "slug":             "default-newsletter",
+                    "show_header_name": false
                 }
             ]
         },
@@ -546,6 +547,11 @@
                     "action_type": "browse",
                     "object_type": "newsletter"
                 },
+                {
+                    "name": "Read newsletters",
+                    "action_type": "read",
+                    "object_type": "newsletter"
+                },
                 {
                     "name": "Add newsletters",
                     "action_type": "add",

package/core/server/data/schema/schema.js

@@ -10,13 +10,14 @@
 module.exports = {
     newsletters: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+        uuid: {type: 'string', maxlength: 36, nullable: false, unique: true, validations: {isUUID: true}},
         name: {type: 'string', maxlength: 191, nullable: false, unique: true},
         description: {type: 'string', maxlength: 2000, nullable: true},
         slug: {type: 'string', maxlength: 191, nullable: false, unique: true},
         sender_name: {type: 'string', maxlength: 191, nullable: true},
         sender_email: {type: 'string', maxlength: 191, nullable: true},
         sender_reply_to: {type: 'string', maxlength: 191, nullable: false, defaultTo: 'newsletter', validations: {isIn: [['newsletter', 'support']]}},
-        status: {type: 'string', maxlength: 50, nullable: false, defaultTo: 'active'},
+        status: {type: 'string', maxlength: 50, nullable: false, defaultTo: 'active', validations: {isIn: [['active', 'archived']]}},
         visibility: {
             type: 'string',
             maxlength: 50,
@@ -33,7 +34,10 @@ module.exports = {
         show_feature_image: {type: 'bool', nullable: false, defaultTo: true},
         body_font_category: {type: 'string', maxlength: 191, nullable: false, defaultTo: 'sans_serif', validations: {isIn: [['serif', 'sans_serif']]}},
         footer_content: {type: 'text', maxlength: 1000000000, nullable: true},
-        show_badge: {type: 'bool', nullable: false, defaultTo: true}
+        show_badge: {type: 'bool', nullable: false, defaultTo: true},
+        show_header_name: {type: 'bool', nullable: false, defaultTo: true},
+        created_at: {type: 'dateTime', nullable: false},
+        updated_at: {type: 'dateTime', nullable: true}
     },
     posts: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
@@ -596,7 +600,8 @@ module.exports = {
         member_id: {type: 'string', maxlength: 24, nullable: false, unique: false, references: 'members.id', cascadeDelete: true},
         subscribed: {type: 'bool', nullable: false, defaultTo: true},
         created_at: {type: 'dateTime', nullable: false},
-        source: {type: 'string', maxlength: 50, nullable: true}
+        source: {type: 'string', maxlength: 50, nullable: true},
+        newsletter_id: {type: 'string', maxlength: 24, nullable: true, references: 'newsletters.id', cascadeDelete: false}
     },
     stripe_products: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},

package/core/server/models/base/plugins/generate-slug.js

@@ -79,7 +79,7 @@ module.exports = function (Bookshelf) {
             // If it's a user, let's try to cut it down (unless this is a human request)
             if (baseName === 'user' && options && options.shortSlug && slugTryCount === 1 && slug !== 'ghost-owner') {
                 longSlug = slug;
-                slug = (slug.indexOf('-') > -1) ? slug.substr(0, slug.indexOf('-')) : slug;
+                slug = (slug.indexOf('-') > -1) ? slug.slice(0, slug.indexOf('-')) : slug;
             }
 
             if (!_.has(options, 'importing') || !options.importing) {
@@ -118,4 +118,4 @@ module.exports = function (Bookshelf) {
  * @property {boolean} [importing] Set to true to don't cut the slug on import
  * @property {boolean} [shortSlug] If it's a user, let's try to cut it down (unless this is a human request)
  * @property {boolean} [skipDuplicateChecks] Don't append unique identifiers when the slug is not unique (this prevents any database queries)
- */
+ */

package/core/server/models/email.js

@@ -54,6 +54,10 @@ const Email = ghostBookshelf.Model.extend({
         return this.hasMany('EmailRecipient', 'email_id');
     },
 
+    newsletter() {
+        return this.belongsTo('Newsletter', 'newsletter_id');
+    },
+
     emitChange: function emitChange(event, options) {
         const eventToTrigger = 'email' + '.' + event;
         ghostBookshelf.Model.prototype.emitChange.bind(this)(this, eventToTrigger, options);

package/core/server/models/label.js

@@ -92,7 +92,7 @@ Label = ghostBookshelf.Model.extend({
     permittedOptions: function permittedOptions(methodName) {
         let options = ghostBookshelf.Model.permittedOptions.call(this, methodName);
 
-        // whitelists for the `options` hash argument on methods, by method name.
+        // allowlists for the `options` hash argument on methods, by method name.
         // these are the only options that can be passed to Bookshelf / Knex.
         const validOptions = {
             findAll: ['columns'],

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

@@ -8,6 +8,10 @@ const MemberSubscribeEvent = ghostBookshelf.Model.extend({
         return this.belongsTo('Member', 'member_id', 'id');
     },
 
+    newsletter() {
+        return this.belongsTo('Newsletter', 'newsletter_id', 'id');
+    },
+
     customQuery(qb, options) {
         if (options.aggregateSubscriptionDeltas) {
             if (options.limit || options.filter) {

package/core/server/models/member.js

@@ -370,6 +370,32 @@ const Member = ghostBookshelf.Model.extend({
             query.transacting(unfilteredOptions.transacting);
         }
 
+        return query;
+    },
+
+    getNewsletterRelations(data, unfilteredOptions = {}) {
+        const query = ghostBookshelf.knex('members_newsletters')
+            .select('id')
+            .whereIn('member_id', data.memberIds);
+
+        if (unfilteredOptions.transacting) {
+            query.transacting(unfilteredOptions.transacting);
+        }
+
+        return query;
+    },
+
+    fetchAllSubscribed(unfilteredOptions = {}) {
+        // we use raw queries instead of model relationships because model hydration is expensive
+        const query = ghostBookshelf.knex('members_newsletters')
+            .join('newsletters', 'members_newsletters.newsletter_id', '=', 'newsletters.id')
+            .where('newsletters.status', 'active')
+            .distinct('member_id as id');
+
+        if (unfilteredOptions.transacting) {
+            query.transacting(unfilteredOptions.transacting);
+        }
+
         return query;
     }
 });

package/core/server/models/newsletter.js

@@ -1,21 +1,40 @@
 const ghostBookshelf = require('./base');
+const ObjectID = require('bson-objectid');
+const uuid = require('uuid');
 
 const Newsletter = ghostBookshelf.Model.extend({
     tableName: 'newsletters',
 
-    defaults: {
-        sender_reply_to: 'newsletter',
-        status: 'active',
-        visibility: 'members',
-        subscribe_on_signup: true,
-        sort_order: 0,
-        title_font_category: 'sans_serif',
-        title_alignment: 'center',
-        show_feature_image: true,
-        body_font_category: 'sans_serif',
-        show_badge: true,
-        show_header_icon: true,
-        show_header_title: true
+    defaults: function defaults() {
+        return {
+            uuid: uuid.v4(),
+            sender_reply_to: 'newsletter',
+            status: 'active',
+            visibility: 'members',
+            subscribe_on_signup: true,
+            sort_order: 0,
+            title_font_category: 'sans_serif',
+            title_alignment: 'center',
+            show_feature_image: true,
+            body_font_category: 'sans_serif',
+            show_badge: true,
+            show_header_icon: true,
+            show_header_title: true,
+            show_header_name: true
+        };
+    },
+
+    members() {
+        return this.belongsToMany('Member', 'members_newsletters', 'newsletter_id', 'member_id')
+            .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('members.*');
+            });
+    },
+
+    posts() {
+        return this.hasMany('Post');
     },
 
     async onSaving(model, _attr, options) {
@@ -36,12 +55,76 @@ const Newsletter = ghostBookshelf.Model.extend({
                 model.set({slug: cleanSlug});
             }
         }
+    },
+
+    subscribeMembersById(memberIds, unfilteredOptions = {}) {
+        let pivotRows = [];
+        for (const memberId of memberIds) {
+            pivotRows.push({
+                id: ObjectID().toHexString(),
+                member_id: memberId.id,
+                newsletter_id: this.id
+            });
+        }
+
+        const query = ghostBookshelf.knex.batchInsert('members_newsletters', pivotRows);
+
+        if (unfilteredOptions.transacting) {
+            query.transacting(unfilteredOptions.transacting);
+        }
+
+        return query;
     }
 }, {
+    orderDefaultRaw: function () {
+        return 'sort_order ASC, created_at ASC, id ASC';
+    },
+
     orderDefaultOptions: function orderDefaultOptions() {
         return {
-            sort_order: 'ASC'
+            sort_order: 'ASC',
+            created_at: 'ASC',
+            id: 'ASC'
         };
+    },
+
+    getDefaultNewsletter: async function getDefaultNewsletter(unfilteredOptions = {}) {
+        const options = {
+            filter: 'status:active',
+            order: this.orderDefaultRaw(),
+            limit: 1
+        };
+
+        if (unfilteredOptions.transacting) {
+            options.transacting = unfilteredOptions.transacting;
+        }
+
+        const newsletters = await this.findPage(options);
+
+        if (newsletters.data.length > 0) {
+            return newsletters.data[0];
+        }
+        return null;
+    },
+
+    getNextAvailableSortOrder: async function getNextAvailableSortOrder(unfilteredOptions = {}) {
+        const options = {
+            filter: 'status:active',
+            order: 'sort_order DESC', // there's no NQL syntax available here
+            limit: 1,
+            columns: ['sort_order']
+        };
+
+        if (unfilteredOptions.transacting) {
+            options.transacting = unfilteredOptions.transacting;
+        }
+
+        const lastNewsletter = await this.findPage(options);
+
+        if (lastNewsletter.data.length > 0) {
+            return lastNewsletter.data[0].get('sort_order') + 1;
+        }
+        return 0;
     }
 });