ghost 4.47.4 → 5.0.1

package/core/server/services/posts/post-scheduling-service.js

@@ -3,7 +3,7 @@ const errors = require('@tryghost/errors');
 const moment = require('moment');
 const config = require('../../../shared/config');
 const urlUtils = require('../../../shared/url-utils');
-const api = require('../../api');
+const api = require('../../api').endpoints;
 
 const messages = {
     jobNotFound: 'Job not found.',
@@ -11,15 +11,6 @@ const messages = {
 };
 
 class PostSchedulingService {
-    /**
-     *
-     * @param {Object} options
-     * @param {String} options.apiVersion - api version
-     */
-    constructor({apiVersion}) {
-        this.api = api[apiVersion];
-    }
-
     /**
      * Publishes scheduled resource (a post or a page at the moment of writing)
      *
@@ -32,7 +23,7 @@ class PostSchedulingService {
     async publish(resourceType, id, force, options) {
         const publishAPostBySchedulerToleranceInMinutes = config.get('times').publishAPostBySchedulerToleranceInMinutes;
 
-        const result = await this.api[resourceType].read({id}, options);
+        const result = await api[resourceType].read({id}, options);
         const preScheduledResource = result[resourceType][0];
 
         const publishedAtMoment = moment(preScheduledResource.published_at);
@@ -51,7 +42,7 @@ class PostSchedulingService {
             updated_at: moment(preScheduledResource.updated_at).toISOString(true)
         }];
 
-        const editResult = await this.api[resourceType].edit(
+        const editResult = await api[resourceType].edit(
             editedResource,
             _.pick(options, ['context', 'id', 'transacting', 'forUpdate'])
         );
@@ -88,13 +79,10 @@ class PostSchedulingService {
 }
 
 /**
- * @param {string} apiVersion - API version to use within the service
  * @returns {PostSchedulingService} instance of the PostsService
  */
-const getPostSchedulingServiceInstance = (apiVersion) => {
-    return new PostSchedulingService({
-        apiVersion: apiVersion
-    });
+const getPostSchedulingServiceInstance = () => {
+    return new PostSchedulingService();
 };
 
 module.exports = getPostSchedulingServiceInstance;

package/core/server/services/posts/posts-service.js

@@ -3,14 +3,12 @@ const {BadRequestError} = require('@tryghost/errors');
 const tpl = require('@tryghost/tpl');
 
 const messages = {
-    invalidEmailRecipientFilter: 'Invalid filter in email_recipient_filter param.',
     invalidVisibilityFilter: 'Invalid visibility filter.',
-    invalidNewsletterId: 'The newsletter_id parameter doesn\'t match any active newsletter.'
+    invalidEmailSegment: 'The email segment parameter doesn\'t contain a valid filter'
 };
 
 class PostsService {
-    constructor({mega, apiVersion, urlUtils, models, isSet}) {
-        this.apiVersion = apiVersion;
+    constructor({mega, urlUtils, models, isSet}) {
         this.mega = mega;
         this.urlUtils = urlUtils;
         this.models = models;
@@ -18,76 +16,33 @@ class PostsService {
     }
 
     async editPost(frame) {
-        let model;
-
-        // Make sure the newsletter_id is matching an active newsletter
-        if (frame.options.newsletter_id) {
-            const newsletter = await this.models.Newsletter.findOne({id: frame.options.newsletter_id}, {transacting: frame.options.transacting});
-            if (!newsletter || newsletter.get('status') !== 'active') {
-                throw new BadRequestError({
-                    message: messages.invalidNewsletterId
-                });
-            }
-        } else {
-            // Set the newsletter_id if it isn't passed to the API
-            // NOTE: this option is ignored if the newsletter_id is already set on the post.
-            // Never use frame.options.newsletter_id to do actual logic. Use model.newsletter_id after the edit.
-            const newsletters = await this.models.Newsletter.findPage({filter: 'status:active', limit: 1, columns: ['id']}, {transacting: frame.options.transacting});
-            if (newsletters.data.length > 0) {
-                frame.options.newsletter_id = newsletters.data[0].id;
-            }
-        }
-
-        if (!frame.options.email_recipient_filter && frame.options.send_email_when_published) {
-            await this.models.Base.transaction(async (transacting) => {
-                const options = {
-                    ...frame.options,
-                    transacting
-                };
-
-                /**
-                 * 1. We need to edit the post first in order to know what the visibility is.
-                 * 2. We can only pass the email_recipient_filter when we change the status.
-                 *
-                 * So, we first edit the post as requested, with all information except the status,
-                 * from there we can determine what the email_recipient_filter should be and then finish
-                 * the edit, with the status and the email_recipient_filter option.
-                 */
-                const status = frame.data.posts[0].status;
-                delete frame.data.posts[0].status;
-                const interimModel = await this.models.Post.edit(frame.data.posts[0], options);
-                frame.data.posts[0].status = status;
-
-                options.email_recipient_filter = interimModel.get('visibility') === 'paid' ? 'paid' : 'all';
-
-                model = await this.models.Post.edit(frame.data.posts[0], options);
-            });
-        } else {
-            model = await this.models.Post.edit(frame.data.posts[0], frame.options);
-        }
-
-        /**Handle newsletter email */
-        const emailRecipientFilter = model.get('email_recipient_filter');
-        if (emailRecipientFilter !== 'none') {
-            if (emailRecipientFilter !== 'all') {
+        // Make sure the newsletter is matching an active newsletter
+        // Note that this option is simply ignored if the post isn't published or scheduled
+        if (frame.options.newsletter && frame.options.email_segment) {
+            if (frame.options.email_segment !== 'all') {
                 // check filter is valid
                 try {
-                    await this.models.Member.findPage({filter: `subscribed:true+${emailRecipientFilter}`, limit: 1});
+                    await this.models.Member.findPage({filter: frame.options.email_segment, limit: 1});
                 } catch (err) {
                     return Promise.reject(new BadRequestError({
-                        message: tpl(messages.invalidEmailRecipientFilter),
+                        message: tpl(messages.invalidEmailSegment),
                         context: err.message
                     }));
                 }
             }
+        }
+
+        const model = await this.models.Post.edit(frame.data.posts[0], frame.options);
 
+        /**Handle newsletter email */
+        if (model.get('newsletter_id')) {
             const sendEmail = model.wasChanged() && this.shouldSendEmail(model.get('status'), model.previous('status'));
 
             if (sendEmail) {
                 let postEmail = model.relations.email;
 
                 if (!postEmail) {
-                    const email = await this.mega.addEmail(model, {...frame.options, apiVersion: this.apiVersion});
+                    const email = await this.mega.addEmail(model, frame.options);
                     model.set('email', email);
                 } else if (postEmail && postEmail.get('status') === 'failed') {
                     const email = await this.mega.retryFailedEmail(postEmail);
@@ -159,17 +114,15 @@ class PostsService {
 }
 
 /**
- * @param {string} apiVersion - API version to use within the service
  * @returns {PostsService} instance of the PostsService
  */
-const getPostServiceInstance = (apiVersion) => {
+const getPostServiceInstance = () => {
     const urlUtils = require('../../../shared/url-utils');
     const {mega} = require('../mega');
     const labs = require('../../../shared/labs');
     const models = require('../../models');
 
     return new PostsService({
-        apiVersion: apiVersion,
         mega: mega,
         urlUtils: urlUtils,
         models: models,

package/core/server/services/public-config/site.js

@@ -2,7 +2,6 @@ const ghostVersion = require('@tryghost/version');
 const settingsCache = require('../../../shared/settings-cache');
 const config = require('../../../shared/config');
 const urlUtils = require('../../../shared/url-utils');
-const labs = require('../../../shared/labs');
 
 module.exports = function getSiteProperties() {
     const siteProperties = {
@@ -15,11 +14,6 @@ module.exports = function getSiteProperties() {
         version: ghostVersion.safe
     };
 
-    if (labs.isSet('oauthLogin') && settingsCache.get('oauth_client_id') && settingsCache.get('oauth_client_secret')) {
-        // Only set the oauth flag if oauth is enabled to avoid API changes
-        siteProperties.oauth = true;
-    }
-
     if (config.get('client_sentry') && !config.get('client_sentry').disabled) {
         siteProperties.sentry_dsn = config.get('client_sentry').dsn;
         siteProperties.sentry_env = config.get('env');

package/core/server/services/route-settings/index.js

@@ -28,9 +28,6 @@ module.exports = {
         return await defaultSettingsManager.ensureSettingsFileExists();
     },
 
-    get loadRouteSettingsSync() {
-        return settingsLoader.loadSettingsSync.bind(settingsLoader);
-    },
     get loadRouteSettings() {
         return settingsLoader.loadSettings.bind(settingsLoader);
     },

package/core/server/services/route-settings/settings-loader.js

@@ -21,10 +21,9 @@ class SettingsLoader {
     }
 
     /**
-     * Functionally same as loadSettingsSync with exception of loading
-     * settings asynchronously. This method is used at new places to read settings
-     * to prevent blocking the eventloop
-     * @returns {Promise<Object>} settingsFile
+     * Reads the routes.yaml settings file and passes the
+    * file to the YAML parser which then returns a JSON object.
+     * @returns {Promise<RouteSettings>} settingsFileContents
      */
     async loadSettings() {
         try {
@@ -49,36 +48,13 @@ class SettingsLoader {
             });
         }
     }
-
-    /**
-     * Reads the routes.yaml settings file and passes the
-     * file to the YAML parser which then returns a JSON object.
-     *
-     * @returns {Object} settingsFile in following format: {routes: {}, collections: {}, resources: {}}
-     */
-    loadSettingsSync() {
-        try {
-            const file = fs.readFileSync(this.settingFilePath, 'utf8');
-            debug('routes settings file found for:', this.settingFilePath);
-
-            const object = this.parseYaml(file);
-            debug('YAML settings file parsed:', this.settingFilePath);
-
-            return validate(object);
-        } catch (err) {
-            if (errors.utils.isGhostError(err)) {
-                throw err;
-            }
-
-            throw new errors.InternalServerError({
-                message: tpl(messages.settingsLoaderError, {
-                    setting: 'routes',
-                    path: this.settingFilePath
-                }),
-                err: err
-            });
-        }
-    }
 }
 
 module.exports = SettingsLoader;
+
+/**
+ * @typedef {Object} RouteSettings
+ * @property {Object} routes
+ * @property {Object} collections
+ * @property {Object} taxonomies
+ */

package/core/server/services/route-settings/validate.js

@@ -1,8 +1,6 @@
 const _ = require('lodash');
-const debug = require('@tryghost/debug')('frontend:services:settings:validate');
 const tpl = require('@tryghost/tpl');
 const errors = require('@tryghost/errors');
-const bridge = require('../../../bridge');
 const _private = {};
 let RESOURCE_CONFIG;
 
@@ -430,12 +428,8 @@ module.exports = function validate(object) {
         object.taxonomies = {};
     }
 
-    const apiVersion = bridge.getFrontendApiVersion();
-
-    debug('api version', apiVersion);
-
     // TODO: extract this config outta here! the config should be passed into this module
-    RESOURCE_CONFIG = require(`../../../frontend/services/routing/config/${apiVersion}`);
+    RESOURCE_CONFIG = require('../../../frontend/services/routing/config');
 
     object.routes = _private.validateRoutes(object.routes);
     object.collections = _private.validateCollections(object.collections);

package/core/server/services/settings/index.js

@@ -1,77 +1 @@
-/**
- * Settings Lib
- * A collection of utilities for handling settings including a cache
- */
-const events = require('../../lib/common/events');
-const models = require('../../models');
-const labs = require('../../../shared/labs');
-const SettingsCache = require('../../../shared/settings-cache');
-const SettingsBREADService = require('./settings-bread-service');
-const {obfuscatedSetting, isSecretSetting, hideValueIfSecret} = require('./settings-utils');
-
-/**
- * @returns {SettingsBREADService} instance of the PostsService
- */
-const getSettingsBREADServiceInstance = () => {
-    return new SettingsBREADService({
-        SettingsModel: models.Settings,
-        settingsCache: SettingsCache,
-        labsService: labs
-    });
-};
-
-module.exports = {
-    /**
-     * Initialize the cache, used in boot and in testing
-     */
-    async init() {
-        const settingsCollection = await models.Settings.populateDefaults();
-        SettingsCache.init(events, settingsCollection);
-    },
-
-    /**
-     * Restore the cache, used during e2e testing only
-     */
-    reset() {
-        SettingsCache.reset(events);
-    },
-
-    /**
-     * Handles synchronization of routes.yaml hash loaded in the frontend with
-     * the value stored in the settings table.
-     * getRoutesHash is a function to allow keeping "frontend" decoupled from settings
-     *
-     * @param {function} getRoutesHash function fetching currently loaded routes file hash
-     */
-    async syncRoutesHash(getRoutesHash) {
-        const currentRoutesHash = await getRoutesHash();
-
-        if (SettingsCache.get('routes_hash') !== currentRoutesHash) {
-            return await models.Settings.edit([{
-                key: 'routes_hash',
-                value: currentRoutesHash
-            }], {context: {internal: true}});
-        }
-    },
-
-    /**
-     * Handles email setting synchronization when email has been verified per instance
-     *
-     * @param {boolean} configValue current email verification value from local config
-     */
-    async syncEmailSettings(configValue) {
-        const isEmailDisabled = SettingsCache.get('email_verification_required');
-
-        if (configValue === true && isEmailDisabled) {
-            return await models.Settings.edit([{
-                key: 'email_verification_required',
-                value: false
-            }], {context: {internal: true}});
-        }
-    },
-
-    obfuscatedSetting,
-    isSecretSetting,
-    hideValueIfSecret,
-    getSettingsBREADServiceInstance
-};
+module.exports = require('./settings-service');

package/core/server/services/settings/settings-service.js

@@ -0,0 +1,184 @@
+/**
+ * Settings Lib
+ * A collection of utilities for handling settings including a cache
+ */
+const errors = require('@tryghost/errors');
+const tpl = require('@tryghost/tpl');
+
+const events = require('../../lib/common/events');
+const models = require('../../models');
+const labs = require('../../../shared/labs');
+const config = require('../../../shared/config');
+const SettingsCache = require('../../../shared/settings-cache');
+const SettingsBREADService = require('./settings-bread-service');
+const {obfuscatedSetting, isSecretSetting, hideValueIfSecret} = require('./settings-utils');
+
+const ObjectId = require('bson-objectid');
+
+const messages = {
+    incorrectKeyType: 'type must be one of "direct" or "connect".'
+};
+
+/**
+ * @returns {SettingsBREADService} instance of the PostsService
+ */
+const getSettingsBREADServiceInstance = () => {
+    return new SettingsBREADService({
+        SettingsModel: models.Settings,
+        settingsCache: SettingsCache,
+        labsService: labs
+    });
+};
+
+class CalculatedField {
+    constructor({key, type, group, fn, dependents}) {
+        this.key = key;
+        this.type = type;
+        this.group = group;
+        this.fn = fn;
+        this.dependents = dependents;
+    }
+
+    getSetting() {
+        return {
+            key: this.key,
+            type: this.type,
+            group: this.group,
+            value: this.fn(),
+            // @TODO: remove this hack
+            id: ObjectId().toHexString(),
+            created_at: new Date().toISOString().replace(/\d{3}Z$/, '000Z'),
+            updated_at: new Date().toISOString().replace(/\d{3}Z$/, '000Z')
+        };
+    }
+}
+
+module.exports = {
+    /**
+     * Initialize the cache, used in boot and in testing
+     */
+    async init() {
+        const settingsCollection = await models.Settings.populateDefaults();
+        SettingsCache.init(events, settingsCollection, this.getCalculatedFields());
+    },
+
+    /**
+     * Restore the cache, used during e2e testing only
+     */
+    reset() {
+        SettingsCache.reset(events);
+    },
+
+    isMembersEnabled() {
+        return SettingsCache.get('members_signup_access') !== 'none';
+    },
+
+    isMembersInviteOnly() {
+        return SettingsCache.get('members_signup_access') === 'invite';
+    },
+
+    /**
+     * @param {'direct' | 'connect'} type - The "type" of keys to fetch from settings
+     * @returns {{publicKey: string, secretKey: string} | null}
+     */
+    getStripeKeys(type) {
+        if (type !== 'direct' && type !== 'connect') {
+            throw new errors.IncorrectUsageError({message: tpl(messages.incorrectKeyType)});
+        }
+
+        const secretKey = SettingsCache.get(`stripe_${type === 'connect' ? 'connect_' : ''}secret_key`);
+        const publicKey = SettingsCache.get(`stripe_${type === 'connect' ? 'connect_' : ''}publishable_key`);
+
+        if (!secretKey || !publicKey) {
+            return null;
+        }
+
+        return {
+            secretKey,
+            publicKey
+        };
+    },
+
+    /**
+     * @returns {{publicKey: string, secretKey: string} | null}
+     */
+    getActiveStripeKeys() {
+        const stripeDirect = config.get('stripeDirect');
+
+        if (stripeDirect) {
+            return this.getStripeKeys('direct');
+        }
+
+        const connectKeys = this.getStripeKeys('connect');
+
+        if (!connectKeys) {
+            return this.getStripeKeys('direct');
+        }
+
+        return connectKeys;
+    },
+
+    arePaidMembersEnabled() {
+        return this.isMembersEnabled() && this.getActiveStripeKeys() !== null;
+    },
+
+    getFirstpromoterId() {
+        if (!SettingsCache.get('firstpromoter')) {
+            return null;
+        }
+        return SettingsCache.get('firstpromoter_id');
+    },
+
+    /**
+     *
+     */
+    getCalculatedFields() {
+        const fields = [];
+
+        fields.push(new CalculatedField({key: 'members_enabled', type: 'boolean', group: 'members', fn: this.isMembersEnabled.bind(this), dependents: ['members_signup_access']}));
+        fields.push(new CalculatedField({key: 'members_invite_only', type: 'boolean', group: 'members', fn: this.isMembersInviteOnly.bind(this), dependents: ['members_signup_access']}));
+        fields.push(new CalculatedField({key: 'paid_members_enabled', type: 'boolean', group: 'members', fn: this.arePaidMembersEnabled.bind(this), dependents: ['members_signup_access', 'stripe_secret_key', 'stripe_publishable_key', 'stripe_connect_secret_key', 'stripe_connect_publishable_key']}));
+        fields.push(new CalculatedField({key: 'firstpromoter_account', type: 'string', group: 'firstpromoter', fn: this.getFirstpromoterId.bind(this), dependents: ['firstpromoter', 'firstpromoter_id']}));
+
+        return fields;
+    },
+
+    /**
+     * Handles synchronization of routes.yaml hash loaded in the frontend with
+     * the value stored in the settings table.
+     * getRoutesHash is a function to allow keeping "frontend" decoupled from settings
+     *
+     * @param {function} getRoutesHash function fetching currently loaded routes file hash
+     */
+    async syncRoutesHash(getRoutesHash) {
+        const currentRoutesHash = await getRoutesHash();
+
+        if (SettingsCache.get('routes_hash') !== currentRoutesHash) {
+            return await models.Settings.edit([{
+                key: 'routes_hash',
+                value: currentRoutesHash
+            }], {context: {internal: true}});
+        }
+    },
+
+    /**
+     * Handles email setting synchronization when email has been verified per instance
+     *
+     * @param {boolean} configValue current email verification value from local config
+     */
+    async syncEmailSettings(configValue) {
+        const isEmailDisabled = SettingsCache.get('email_verification_required');
+
+        if (configValue === true && isEmailDisabled) {
+            return await models.Settings.edit([{
+                key: 'email_verification_required',
+                value: false
+            }], {context: {internal: true}});
+        }
+    },
+
+    obfuscatedSetting,
+    isSecretSetting,
+    hideValueIfSecret,
+    getSettingsBREADServiceInstance
+};

package/core/server/services/themes/validate.js

@@ -22,7 +22,7 @@ const check = async function check(theme, isZip) {
     debug('Begin: Check');
     // gscan can slow down boot time if we require on boot, for now nest the require.
     const gscan = require('gscan');
-    const checkedVersion = 'v4';
+    const checkedVersion = 'v5';
     let checkedTheme;
 
     if (isZip) {

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

@@ -59,9 +59,7 @@ class Resources {
             return;
         }
 
-        const bridge = require('../../../bridge');
-        const resourcesAPIVersion = bridge.getFrontendApiVersion();
-        this.resourcesConfig = require(`./configs/${resourcesAPIVersion}`);
+        this.resourcesConfig = require('./config');
     }
 
     /**

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

@@ -204,7 +204,7 @@ class UrlGenerator {
      * If the owned resource get's updated, we simply release/free the resource and push it back to the queue.
      * This is the easiest, less error prone implementation.
      *
-     * Imagine you have two collections: `featured:true` and `page:false`.
+     * Imagine you have two collections: `featured:true` and `type:page`.
      * If a published post status get's featured and you have not explicitly defined `featured:false`, we wouldn't
      * be able to figure out if this resource still belongs to me, because the filter still matches.
      */

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

@@ -9,9 +9,6 @@ const Urls = require('./Urls');
 const Resources = require('./Resources');
 const urlUtils = require('../../../shared/url-utils');
 
-// This listens to services.themes.api.changed, routing events, and it's own queue events
-const events = require('../../lib/common/events');
-
 /**
  * The url service class holds all instances in a centralized place.
  * It's the public API you can talk to.
@@ -49,9 +46,6 @@ class UrlService {
      * @private
      */
     _listeners() {
-        this._onThemeChangedListener = this._onThemeChangedListener.bind(this);
-        events.on('services.themes.api.changed', this._onThemeChangedListener);
-
         this._onQueueStartedListener = this._onQueueStarted.bind(this);
         this.queue.addListener('started', this._onQueueStartedListener);
 
@@ -120,15 +114,6 @@ class UrlService {
         generator.regenerateResources();
     }
 
-    /**
-     * @description If the API version in the theme config changes, we have to reset urls and resources.
-     * @private
-     */
-    _onThemeChangedListener() {
-        this.reset({keepListeners: true});
-        this.init();
-    }
-
     /**
      * @description Get Resource by url.
      *
@@ -233,6 +218,8 @@ class UrlService {
      *
      * @param {String} id
      * @param {Object} options
+     * @param {Object} [options.absolute]
+     * @param {Object} [options.withSubdirectory]
      * @returns {String}
      */
     getUrlByResourceId(id, options) {
@@ -242,22 +229,22 @@ class UrlService {
 
         if (obj) {
             if (options.absolute) {
-                return this.utils.createUrl(obj.url, options.absolute, options.secure);
+                return this.utils.createUrl(obj.url, options.absolute);
             }
 
             if (options.withSubdirectory) {
-                return this.utils.createUrl(obj.url, false, options.secure, true);
+                return this.utils.createUrl(obj.url, false, true);
             }
 
             return obj.url;
         }
 
         if (options.absolute) {
-            return this.utils.createUrl('/404/', options.absolute, options.secure);
+            return this.utils.createUrl('/404/', options.absolute);
         }
 
         if (options.withSubdirectory) {
-            return this.utils.createUrl('/404/', false, options.secure);
+            return this.utils.createUrl('/404/', false);
         }
 
         return '/404/';
@@ -375,7 +362,6 @@ class UrlService {
         if (!options.keepListeners) {
             this._onQueueStartedListener && this.queue.removeListener('started', this._onQueueStartedListener);
             this._onQueueEndedListener && this.queue.removeListener('ended', this._onQueueEndedListener);
-            this._onThemeChangedListener && events.removeListener('services.themes.api.changed', this._onThemeChangedListener);
         }
     }