ghost 4.48.0 → 5.0.0

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

@@ -51,7 +51,7 @@ module.exports = {
         feature_image: {type: 'string', maxlength: 2000, nullable: true},
         featured: {type: 'bool', nullable: false, defaultTo: false},
         type: {type: 'string', maxlength: 50, nullable: false, defaultTo: 'post', validations: {isIn: [['post', 'page']]}},
-        status: {type: 'string', maxlength: 50, nullable: false, defaultTo: 'draft'},
+        status: {type: 'string', maxlength: 50, nullable: false, defaultTo: 'draft', validations: {isIn: [['published', 'draft', 'scheduled', 'sent']]}},
         // NOTE: unused at the moment and reserved for future features
         locale: {type: 'string', maxlength: 6, nullable: true},
         visibility: {
@@ -63,14 +63,8 @@ module.exports = {
         email_recipient_filter: {
             type: 'text',
             maxlength: 1000000000,
-            nullable: false,
-            defaultTo: 'none'
+            nullable: false
         },
-        /**
-         * @deprecated: single authors was superceded by multiple authors in Ghost 1.22.0
-         * If we keep it, then only, because you can easier query post.author_id than posts_authors[*].sort_order.
-         */
-        author_id: {type: 'string', maxlength: 24, nullable: false},
         created_at: {type: 'dateTime', nullable: false},
         /**
          * @deprecated: https://github.com/TryGhost/Ghost/issues/10286
@@ -109,6 +103,7 @@ module.exports = {
         feature_image_caption: {type: 'text', maxlength: 65535, nullable: true},
         email_only: {type: 'bool', nullable: false, defaultTo: false}
     },
+    // NOTE: this is the staff table
     users: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         name: {type: 'string', maxlength: 191, nullable: false},
@@ -123,10 +118,23 @@ module.exports = {
         facebook: {type: 'string', maxlength: 2000, nullable: true},
         twitter: {type: 'string', maxlength: 2000, nullable: true},
         accessibility: {type: 'text', maxlength: 65535, nullable: true},
-        // TODO: would be good to add validation here to control for all possible status values.
-        //       The ones that come up by reviewing the user model are:
-        //       'active', 'inactive', 'locked', 'warn-1', 'warn-2', 'warn-3', 'warn-4'
-        status: {type: 'string', maxlength: 50, nullable: false, defaultTo: 'active'},
+        status: {
+            type: 'string',
+            maxlength: 50,
+            nullable: false,
+            defaultTo: 'active',
+            validations: {
+                isIn: [[
+                    'active',
+                    'inactive',
+                    'locked',
+                    'warn-1',
+                    'warn-2',
+                    'warn-3',
+                    'warn-4'
+                ]]
+            }
+        },
         // NOTE: unused at the moment and reserved for future features
         locale: {type: 'string', maxlength: 6, nullable: true},
         visibility: {
@@ -145,16 +153,6 @@ module.exports = {
         updated_at: {type: 'dateTime', nullable: true},
         updated_by: {type: 'string', maxlength: 24, nullable: true}
     },
-    oauth: {
-        id: {type: 'string', maxlength: 24, nullable: false, primary: true},
-        provider: {type: 'string', maxlength: 50, nullable: false},
-        provider_id: {type: 'string', maxlength: 191, nullable: false},
-        access_token: {type: 'text', maxlength: 65535, nullable: true},
-        refresh_token: {type: 'text', maxlength: 2000, nullable: true},
-        created_at: {type: 'dateTime', nullable: false},
-        updated_at: {type: 'dateTime', nullable: true},
-        user_id: {type: 'string', maxlength: 24, nullable: false, references: 'users.id'}
-    },
     posts_authors: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         post_id: {type: 'string', maxlength: 24, nullable: false, references: 'posts.id'},
@@ -337,13 +335,12 @@ module.exports = {
         target_url: {type: 'string', maxlength: 2000, nullable: false},
         name: {type: 'string', maxlength: 191, nullable: true},
         secret: {type: 'string', maxlength: 191, nullable: true},
-        // NOTE: the defaultTo does not make sense to set on DB layer as it leads to unnecessary maintenance every major release
-        //       it might make sense to introduce "isIn" validation checking if it's a valid version e.g: 'v3', 'v4', 'canary'
+        // @NOTE: the defaultTo does not make sense to set on DB layer as it leads to unnecessary maintenance every major release
+        //       would be ideal if we can remove the default and instead have "isIn" validation checking if it's a valid version e.g: 'v3', 'v4', 'canary'
         api_version: {type: 'string', maxlength: 50, nullable: false, defaultTo: 'v2'},
         // NOTE: integration_id column needs "nullable: true" -> "nullable: false" migration (recreate table with nullable: false)
         // CASE: Ghost instances initialized pre 4.0 will have this column set to nullable: true in db schema
         integration_id: {type: 'string', maxlength: 24, nullable: false, references: 'integrations.id', cascadeDelete: true},
-        status: {type: 'string', maxlength: 50, nullable: false, defaultTo: 'available'},
         last_triggered_at: {type: 'dateTime', nullable: true},
         last_triggered_status: {type: 'string', maxlength: 50, nullable: true},
         last_triggered_error: {type: 'string', maxlength: 50, nullable: true},
@@ -397,7 +394,6 @@ module.exports = {
         name: {type: 'string', maxlength: 191, nullable: true},
         note: {type: 'string', maxlength: 2000, nullable: true},
         geolocation: {type: 'string', maxlength: 2000, nullable: true},
-        subscribed: {type: 'bool', nullable: true, defaultTo: true},
         email_count: {type: 'integer', unsigned: true, nullable: false, defaultTo: 0},
         email_opened_count: {type: 'integer', unsigned: true, nullable: false, defaultTo: 0},
         email_open_rate: {type: 'integer', unsigned: true, nullable: true, index: true},
@@ -407,10 +403,12 @@ module.exports = {
         updated_at: {type: 'dateTime', nullable: true},
         updated_by: {type: 'string', maxlength: 24, nullable: true}
     },
+    // NOTE: this is the tiers table
     products: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         name: {type: 'string', maxlength: 191, nullable: false},
         slug: {type: 'string', maxlength: 191, nullable: false, unique: true},
+        // @deprecated: use a status enum with isIn validation, not aan ctive boolean
         active: {type: 'boolean', nullable: false, defaultTo: true},
         welcome_page_url: {type: 'string', maxlength: 2000, nullable: true},
         visibility: {
@@ -429,6 +427,7 @@ module.exports = {
     },
     offers: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+        // @deprecated: use a status enum with isIn validation, not aan ctive boolean
         active: {type: 'boolean', nullable: false, defaultTo: true},
         name: {type: 'string', maxlength: 191, nullable: false, unique: true},
         code: {type: 'string', maxlength: 191, nullable: false, unique: true},
@@ -651,8 +650,7 @@ module.exports = {
         recipient_filter: {
             type: 'text',
             maxlength: 1000000000,
-            nullable: false,
-            defaultTo: 'status:-free'
+            nullable: false
         },
         error: {type: 'string', maxlength: 2000, nullable: true},
         error_data: {type: 'text', maxlength: 1000000000, fieldtype: 'long', nullable: true},
@@ -720,16 +718,6 @@ module.exports = {
         updated_at: {type: 'dateTime', nullable: true},
         updated_by: {type: 'string', maxlength: 24, nullable: true}
     },
-    temp_member_analytic_events: {
-        id: {type: 'string', maxlength: 24, nullable: false, primary: true},
-        event_name: {type: 'string', maxlength: 50, nullable: false},
-        created_at: {type: 'dateTime', nullable: false},
-        member_id: {type: 'string', maxlength: 24, nullable: false},
-        member_status: {type: 'string', maxlength: 50, nullable: false},
-        entry_id: {type: 'string', maxlength: 24, nullable: true},
-        source_url: {type: 'string', maxlength: 2000, nullable: true},
-        metadata: {type: 'string', maxlength: 191, nullable: true}
-    },
     custom_theme_settings: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         theme: {type: 'string', maxlength: 191, nullable: false},

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

@@ -45,6 +45,8 @@ function validateSchema(tableName, model, options) {
         // check nullable
         if (Object.prototype.hasOwnProperty.call(schema[tableName][columnKey], 'nullable') &&
             schema[tableName][columnKey].nullable !== true &&
+            Object.prototype.hasOwnProperty.call(schema[tableName][columnKey], 'type') &&
+            schema[tableName][columnKey].type !== 'text' &&
             !Object.prototype.hasOwnProperty.call(schema[tableName][columnKey], 'defaultTo')
         ) {
             if (validator.isEmpty(strVal)) {

package/core/server/ghost-server.js

@@ -1,12 +1,6 @@
 // # Ghost Server
 // Handles the creation of an HTTP Server for Ghost
 const debug = require('@tryghost/debug')('server');
-
-const Promise = require('bluebird');
-const fs = require('fs-extra');
-const path = require('path');
-const _ = require('lodash');
-const config = require('../shared/config');
 const errors = require('@tryghost/errors');
 const tpl = require('@tryghost/tpl');
 const logging = require('@tryghost/logging');
@@ -42,14 +36,25 @@ const messages = {
  * ## GhostServer
  */
 class GhostServer {
-    constructor({url}) {
+    /**
+     *
+     * @param {Object}  options
+     * @param {String}  options.url
+     * @param {String}  options.env development|production|testing
+     * @param {Object}  options.serverConfig
+     * @param {String}  options.serverConfig.host
+     * @param {Number}  options.serverConfig.port
+     * @param {Number}  options.serverConfig.shutdownTimeout
+     * @param {Boolean} options.serverConfig.testmode
+     */
+    constructor({url, env, serverConfig}) {
         this.url = url;
+        this.env = env;
+        this.serverConfig = serverConfig;
+
         this.rootApp = null;
         this.httpServer = null;
 
-        // Expose config module for use externally.
-        this.config = config;
-
         // Tasks that should be run before the server exits
         this.cleanupTasks = [];
     }
@@ -66,42 +71,16 @@ class GhostServer {
      */
     start(rootApp) {
         debug('Starting...');
-        const self = this;
-        self.rootApp = rootApp;
-        let socketConfig;
+        this.rootApp = rootApp;
 
-        const socketValues = {
-            path: path.join(config.get('paths').contentPath, config.get('env') + '.socket'),
-            permissions: '660'
-        };
+        const {host, port, testmode, shutdownTimeout} = this.serverConfig;
+        const self = this;
 
         return new Promise(function (resolve, reject) {
-            if (_.has(config.get('server'), 'socket')) {
-                socketConfig = config.get('server').socket;
-
-                if (_.isString(socketConfig)) {
-                    socketValues.path = socketConfig;
-                } else if (_.isObject(socketConfig)) {
-                    socketValues.path = socketConfig.path || socketValues.path;
-                    socketValues.permissions = socketConfig.permissions || socketValues.permissions;
-                }
-
-                // Make sure the socket is gone before trying to create another
-                try {
-                    fs.unlinkSync(socketValues.path);
-                } catch (e) {
-                    // We can ignore this.
-                }
-
-                self.httpServer = rootApp.listen(socketValues.path);
-                fs.chmod(socketValues.path, socketValues.permissions);
-                config.set('server:socket', socketValues);
-            } else {
-                self.httpServer = rootApp.listen(
-                    config.get('server').port,
-                    config.get('server').host
-                );
-            }
+            self.httpServer = rootApp.listen(
+                port,
+                host
+            );
 
             self.httpServer.on('error', function (error) {
                 let ghostError;
@@ -109,7 +88,7 @@ class GhostServer {
                 if (error.code === 'EADDRINUSE') {
                     ghostError = new errors.InternalServerError({
                         message: tpl(messages.addressInUse.error),
-                        context: tpl(messages.addressInUse.context, {port: config.get('server').port}),
+                        context: tpl(messages.addressInUse.context, {port}),
                         help: tpl(messages.addressInUse.help)
                     });
                 } else {
@@ -132,7 +111,7 @@ class GhostServer {
                 self._logStartMessages();
 
                 // Debug logs output in testmode only
-                if (config.get('server:testmode')) {
+                if (testmode) {
                     self._startTestMode();
                 }
 
@@ -143,7 +122,7 @@ class GhostServer {
                     });
             });
 
-            stoppable(self.httpServer, config.get('server:shutdownTimeout'));
+            stoppable(self.httpServer, shutdownTimeout);
 
             // ensure that Ghost exits correctly on Ctrl+C and SIGTERM
             process
@@ -177,7 +156,7 @@ class GhostServer {
      * Stops the server & handles cleanup, but does not exit the process
      * Used in tests for quick start/stop actions
      * Called by shutdown to handle server stop and cleanup before exiting
-     * @returns {Promise} Resolves once Ghost has stopped
+     * @returns {Promise<any>} Resolves once Ghost has stopped
      */
     async stop() {
         try {
@@ -221,22 +200,13 @@ class GhostServer {
      * If server.shutdownTimeout is reached, requests are terminated in-flight
      */
     async _stopServer() {
-        return new Promise((resolve, reject) => {
-            this.httpServer
-                .stop((error, status) => {
-                    if (error) {
-                        return reject(error);
-                    }
-
-                    return resolve(status);
-                });
-        });
+        const util = require('util');
+        return util.promisify(this.httpServer.stop)();
     }
 
     async _cleanup() {
         // Wait for all cleanup tasks to finish
-        await Promise
-            .all(this.cleanupTasks.map(task => task()));
+        return Promise.all(this.cleanupTasks.map(task => task()));
     }
 
     /**
@@ -281,14 +251,14 @@ class GhostServer {
      * Log Start Messages
      */
     _logStartMessages() {
-        logging.info(tpl(messages.ghostIsRunningIn, {env: config.get('env')}));
+        logging.info(tpl(messages.ghostIsRunningIn, {env: this.env}));
 
-        if (config.get('env') === 'production') {
+        if (this.env === 'production') {
             logging.info(tpl(messages.yourBlogIsAvailableOn, {url: this.url}));
         } else {
             logging.info(tpl(messages.listeningOn, {
-                host: config.get('server').socket || config.get('server').host,
-                port: config.get('server').port
+                host: this.serverConfig.host,
+                port: this.serverConfig.port
             }));
             logging.info(tpl(messages.urlConfiguredAs, {url: this.url}));
         }
@@ -303,7 +273,7 @@ class GhostServer {
         logging.warn(tpl(messages.ghostHasShutdown));
 
         // Extra clear message for production mode
-        if (config.get('env') === 'production') {
+        if (this.env === 'production') {
             logging.warn(tpl(messages.yourBlogIsNowOffline));
         }
 

package/core/server/lib/image/gravatar.js

@@ -1,5 +1,6 @@
 const Promise = require('bluebird');
 const crypto = require('crypto');
+const tpl = require('@tryghost/tpl');
 
 class Gravatar {
     constructor({config, request}) {
@@ -7,21 +8,36 @@ class Gravatar {
         this.request = request;
     }
 
+    url(email, options) {
+        if (options.default) {
+            // tpl errors on token `{default}` so we use `{_default}` instead
+            // but still allow the option to be passed as `default`
+            options._default = options.default;
+        }
+        const defaultOptions = {
+            size: 250,
+            _default: 'blank',
+            rating: 'g'
+        };
+        const emailHash = crypto.createHash('md5').update(email.toLowerCase().trim()).digest('hex');
+        const gravatarUrl = this.config.get('gravatar').url;
+        return tpl(gravatarUrl, Object.assign(defaultOptions, options, {hash: emailHash}));
+    }
+
     lookup(userData, timeout) {
-        let gravatarUrl = '//www.gravatar.com/avatar/' +
-            crypto.createHash('md5').update(userData.email.toLowerCase().trim()).digest('hex') +
-            '?s=250';
-    
         if (this.config.isPrivacyDisabled('useGravatar')) {
             return Promise.resolve();
         }
-    
-        return Promise.resolve(this.request('https:' + gravatarUrl + '&d=404&r=x', {timeout: timeout || 2 * 1000}))
+
+        // test existence using a default 404, but return a different default
+        // so we still have a fallback if the image gets removed from Gravatar
+        const testUrl = this.url(userData.email, {default: 404, rating: 'x'});
+        const imageUrl = this.url(userData.email, {default: 'mp', rating: 'x'});
+
+        return Promise.resolve(this.request(testUrl, {timeout: timeout || 2 * 1000}))
             .then(function () {
-                gravatarUrl += '&d=mm&r=x';
-    
                 return {
-                    image: gravatarUrl
+                    image: imageUrl
                 };
             })
             .catch({statusCode: 404}, function () {

package/core/server/models/api-key.js

@@ -1,36 +1,13 @@
 const omit = require('lodash/omit');
-const crypto = require('crypto');
+const security = require('@tryghost/security');
 const ghostBookshelf = require('./base');
 const {Role} = require('./role');
 
-/*
- * Uses birthday problem estimation to calculate chance of collision
- * d = 16^26        // 26 char hex string
- * n = 10,000,000   // 10 million
- *
- *       (-n x (n-1)) / 2d
- * 1 - e^
- *
- *
- *           17
- * ~= 4 x 10^
- *
- * ref: https://medium.freecodecamp.org/how-long-should-i-make-my-api-key-833ebf2dc26f
- * ref: https://en.wikipedia.org/wiki/Birthday_problem#Approximations
- *
- * 26 char hex string = 13 bytes
- * 64 char hex string JWT secret = 32 bytes
- */
-const createSecret = (type) => {
-    const bytes = type === 'content' ? 13 : 32;
-    return crypto.randomBytes(bytes).toString('hex');
-};
-
 const ApiKey = ghostBookshelf.Model.extend({
     tableName: 'api_keys',
 
     defaults() {
-        const secret = createSecret(this.get('type'));
+        const secret = security.secret.create(this.get('type'));
 
         return {
             secret
@@ -97,7 +74,7 @@ const ApiKey = ghostBookshelf.Model.extend({
     }
 }, {
     refreshSecret(data, options) {
-        const secret = createSecret(data.type);
+        const secret = security.secret.create(data.type);
         return this.edit(Object.assign({}, data, {secret}), options);
     }
 });

package/core/server/models/base/plugins/bulk-operations.js

@@ -52,9 +52,9 @@ async function editMultiple(knex, table, chunk, options) {
     await knex(table).whereIn('id', chunk).update(options.data);
 }
 
-async function delSingle(knex, table, id) {
+async function delSingle(knex, table, id, options) {
     try {
-        await knex(table).where('id', id).del();
+        await knex(table).where(options.column ?? 'id', id).del();
     } catch (err) {
         const importError = new errors.DataImportError({
             message: `Failed to remove entry from ${table}`,
@@ -66,8 +66,8 @@ async function delSingle(knex, table, id) {
     }
 }
 
-async function delMultiple(knex, table, chunk) {
-    await knex(table).whereIn('id', chunk).del();
+async function delMultiple(knex, table, chunk, options) {
+    await knex(table).whereIn(options.column ?? 'id', chunk).del();
 }
 
 const insert = createBulkOperation(insertSingle, insertMultiple);
@@ -91,10 +91,18 @@ module.exports = function (Bookshelf) {
             return edit(Bookshelf.knex, tableName, data, options);
         },
 
-        bulkDestroy: function bulkDestroy(data, tableName) {
+        /**
+         * 
+         * @param {string[]} data List of ids to delete
+         * @param {*} tableName 
+         * @param {Object} [options] 
+         * @param {string} [options.column] Delete the rows where this column equals the ids in `data` (defaults to 'id')
+         * @returns 
+         */
+        bulkDestroy: function bulkDestroy(data, tableName, options = {}) {
             tableName = tableName || this.prototype.tableName;
 
-            return del(Bookshelf.knex, tableName, data);
+            return del(Bookshelf.knex, tableName, data, options);
         }
     });
 };

package/core/server/models/integration.js

@@ -1,3 +1,4 @@
+const _ = require('lodash');
 const limitService = require('../services/limits');
 const ghostBookshelf = require('./base');
 const {NoPermissionError} = require('@tryghost/errors');
@@ -64,6 +65,14 @@ const Integration = ghostBookshelf.Model.extend({
         return options;
     },
 
+    defaultRelations: function defaultRelations(methodName, options) {
+        if (['edit', 'add', 'destroy'].indexOf(methodName) !== -1) {
+            options.withRelated = _.union(['api_keys'], options.withRelated || []);
+        }
+
+        return options;
+    },
+
     async permissible(integrationModel, action, context, attrs, loadedPerms, hasUserPermission, hasApiKeyPermission) {
         const isAdd = (action === 'add');
 
@@ -76,6 +85,14 @@ const Integration = ghostBookshelf.Model.extend({
         if (!hasUserPermission || !hasApiKeyPermission) {
             throw new NoPermissionError();
         }
+    },
+
+    async getInternalFrontendKey(options) {
+        options = options || {};
+
+        options.withRelated = ['api_keys'];
+
+        return this.findOne({slug: 'ghost-internal-frontend'}, options);
     }
 });
 

package/core/server/models/member.js

@@ -2,7 +2,7 @@ const ghostBookshelf = require('./base');
 const uuid = require('uuid');
 const _ = require('lodash');
 const config = require('../../shared/config');
-const crypto = require('crypto');
+const {gravatar} = require('../lib/image');
 
 const Member = ghostBookshelf.Model.extend({
     tableName: 'members',
@@ -10,7 +10,6 @@ const Member = ghostBookshelf.Model.extend({
     defaults() {
         return {
             status: 'free',
-            subscribed: true,
             uuid: uuid.v4(),
             email_count: 0,
             email_opened_count: 0
@@ -30,6 +29,12 @@ const Member = ghostBookshelf.Model.extend({
         }, {
             key: 'products',
             replacement: 'products.slug'
+        }, {
+            key: 'tier',
+            replacement: 'products.slug'
+        }, {
+            key: 'tiers',
+            replacement: 'products.slug'
         }, {
             key: 'newsletters',
             replacement: 'newsletters.slug'
@@ -311,8 +316,7 @@ const Member = ghostBookshelf.Model.extend({
         // Will not use gravatar if privacy.useGravatar is false in config
         attrs.avatar_image = null;
         if (attrs.email && !config.isPrivacyDisabled('useGravatar')) {
-            const emailHash = crypto.createHash('md5').update(attrs.email.toLowerCase().trim()).digest('hex');
-            attrs.avatar_image = `https://gravatar.com/avatar/${emailHash}?s=250&d=blank`;
+            attrs.avatar_image = gravatar.url(attrs.email, {size: 250, default: 'blank'});
         }
 
         return attrs;

package/core/server/models/newsletter.js

@@ -38,6 +38,11 @@ const Newsletter = ghostBookshelf.Model.extend({
         return this.hasMany('Post');
     },
 
+    // Force active newsletters for content API
+    enforcedFilters: function enforcedFilters(options) {
+        return (options.context && options.context.public) ? 'status:active' : null;
+    },
+
     async onSaving(model, _attr, options) {
         ghostBookshelf.Model.prototype.onSaving.apply(this, arguments);
 
@@ -99,6 +104,28 @@ const Newsletter = ghostBookshelf.Model.extend({
         return attrs;
     }
 }, {
+    /**
+     * Returns an array of keys permitted in a method's `options` hash, depending on the current method.
+     * @param {String} methodName The name of the method to check valid options for.
+     * @return {Array} Keys allowed in the `options` hash of the model's method.
+     */
+    permittedOptions: function permittedOptions(methodName) {
+        let options = ghostBookshelf.Model.permittedOptions.call(this, methodName);
+
+        // 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 = {
+            findOne: ['filter'],
+            findAll: ['filter']
+        };
+
+        if (validOptions[methodName]) {
+            options = options.concat(validOptions[methodName]);
+        }
+
+        return options;
+    },
+
     orderDefaultRaw: function () {
         return 'sort_order ASC, created_at ASC, id ASC';
     },