ghost 4.48.0 → 5.0.0

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;
+    },
+
+    isStripeConnected() {
+        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.isStripeConnected.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);
         }
     }
 

package/core/server/services/users.js

@@ -11,7 +11,7 @@ const path = require('path');
  * @prop {Object} Base
  * @prop {(callback: function) => Promise} Base.transaction
  * @prop {Object} Post
- * @prop {(frameOptions: Object) => Promise} Post.destroyByAuthor
+ * @prop {(frameOptions: Object) => Promise} Post.reassignByAuthor
  * @prop {Object} ApiKey
  * @prop {(Object) => Promise} ApiKey.destroy
  * @prop {Object} ApiKey.NotFoundError
@@ -76,7 +76,7 @@ class Users {
         return this.models.Base.transaction(async (t) => {
             frameOptions.transacting = t;
 
-            await this.models.Post.destroyByAuthor(frameOptions);
+            await this.models.Post.reassignByAuthor(frameOptions);
 
             try {
                 await this.models.ApiKey.destroy({

package/core/server/services/webhooks/listen.js

@@ -1,7 +1,9 @@
 const _ = require('lodash');
 const limitService = require('../../services/limits');
 const logging = require('@tryghost/logging');
-const trigger = require('./trigger');
+const WebhookTrigger = require('./trigger');
+const models = require('../../models');
+const payload = require('./payload');
 
 // The webhook system is fundamentally built on top of our model event system
 const events = require('../../lib/common/events');
@@ -55,6 +57,7 @@ const listen = async () => {
         }
     }
 
+    const webhookTrigger = new WebhookTrigger({models, payload});
     _.each(WEBHOOKS, (event) => {
         events.on(event, (model, options) => {
             // CASE: avoid triggering webhooks when importing
@@ -62,7 +65,7 @@ const listen = async () => {
                 return;
             }
 
-            trigger(event, model);
+            webhookTrigger.trigger(event, model);
         });
     });
 };

package/core/server/services/webhooks/serialize.js

@@ -1,9 +1,8 @@
 module.exports = (event, model) => {
     const _ = require('lodash');
     const {sequence} = require('@tryghost/promise');
-    const api = require('../../api');
-
-    const apiVersion = model.get('api_version') || 'v4';
+    const api = require('../../api').endpoints;
+    const apiShared = require('../../api').shared;
 
     const resourceName = event.match(/(\w+)\./)[1];
     const docName = `${resourceName}s`;
@@ -19,10 +18,10 @@ module.exports = (event, model) => {
                 frame.options.withRelated = ['tags', 'authors'];
             }
 
-            return api.shared
+            return apiShared
                 .serializers
                 .handle
-                .output(model, {docName: docName, method: 'read'}, api[apiVersion].serializers.output, frame)
+                .output(model, {docName: docName, method: 'read'}, api.serializers.output, frame)
                 .then(() => {
                     return frame.response[docName][0];
                 });
@@ -42,10 +41,10 @@ module.exports = (event, model) => {
                 frame.options.withRelated = ['tags', 'authors'];
             }
 
-            return api.shared
+            return apiShared
                 .serializers
                 .handle
-                .output(model, {docName: docName, method: 'read'}, api[apiVersion].serializers.output, frame)
+                .output(model, {docName: docName, method: 'read'}, api.serializers.output, frame)
                 .then(() => {
                     return frame.response[docName][0];
                 });

package/core/server/services/webhooks/trigger.js

@@ -1,19 +1,30 @@
-const _ = require('lodash');
 const debug = require('@tryghost/debug')('services:webhooks:trigger');
 const logging = require('@tryghost/logging');
-const request = require('@tryghost/request');
-const models = require('../../models');
-const payload = require('./payload');
+const ghostVersion = require('@tryghost/version');
+
+class WebhookTrigger {
+    /**
+     *
+     * @param {Object} options
+     * @param {Object} options.models - Ghost models
+     * @param {Function} options.payload - Function to generate payload
+     * @param {Object} [options.request] - HTTP request handling library
+     */
+    constructor({models, payload, request}){
+        this.models = models;
+        this.payload = payload;
+
+        this.request = request ?? require('@tryghost/request');
+    }
 
-const webhooks = {
     getAll(event) {
-        return models
+        return this.models
             .Webhook
             .findAllByEvent(event, {context: {internal: true}});
-    },
+    }
 
     update(webhook, data) {
-        models
+        this.models
             .Webhook
             .edit({
                 last_triggered_at: Date.now(),
@@ -23,36 +34,34 @@ const webhooks = {
             .catch(() => {
                 logging.warn(`Unable to update "last_triggered" for webhook: ${webhook.id}`);
             });
-    },
+    }
 
     destroy(webhook) {
-        return models
+        return this.models
             .Webhook
             .destroy({id: webhook.id}, {context: {internal: true}})
             .catch(() => {
                 logging.warn(`Unable to destroy webhook ${webhook.id}.`);
             });
     }
-};
 
-const response = {
     onSuccess(webhook) {
         return (res) => {
-            webhooks.update(webhook, {
+            this.update(webhook, {
                 statusCode: res.statusCode
             });
         };
-    },
+    }
 
     onError(webhook) {
         return (err) => {
             if (err.statusCode === 410) {
                 logging.info(`Webhook destroyed (410 response) for "${webhook.get('event')}" with url "${webhook.get('target_url')}".`);
 
-                return webhooks.destroy(webhook);
+                return this.destroy(webhook);
             }
 
-            webhooks.update(webhook, {
+            this.update(webhook, {
                 statusCode: err.statusCode,
                 error: `Request failed: ${err.code || 'unknown'}`
             });
@@ -60,34 +69,40 @@ const response = {
             logging.warn(`Request to ${webhook.get('target_url') || null} failed because of: ${err.code || ''}.`);
         };
     }
-};
-
-module.exports = (event, model) => {
-    webhooks.getAll(event)
-        .then((hooks) => {
-            debug(`${hooks.models.length} webhooks found for ${event}.`);
-
-            _.each(hooks.models, (webhook) => {
-                payload(webhook.get('event'), model)
-                    .then((hookPayload) => {
-                        const reqPayload = JSON.stringify(hookPayload);
-                        const url = webhook.get('target_url');
-                        const opts = {
-                            body: reqPayload,
-                            headers: {
-                                'Content-Length': Buffer.byteLength(reqPayload),
-                                'Content-Type': 'application/json'
-                            },
-                            timeout: 2 * 1000,
-                            retry: 5
-                        };
-
-                        logging.info(`Triggering webhook for "${webhook.get('event')}" with url "${url}"`);
-
-                        request(url, opts)
-                            .then(response.onSuccess(webhook))
-                            .catch(response.onError(webhook));
-                    });
-            });
-        });
-};
+
+    async trigger(event, model) {
+        const response = {
+            onSuccess: this.onSuccess.bind(this),
+            onError: this.onError.bind(this)
+        };
+
+        const hooks = await this.getAll(event);
+
+        debug(`${hooks.models.length} webhooks found for ${event}.`);
+
+        for (const webhook of hooks.models) {
+            const hookPayload = await this.payload(webhook.get('event'), model);
+
+            const reqPayload = JSON.stringify(hookPayload);
+            const url = webhook.get('target_url');
+            const opts = {
+                body: reqPayload,
+                headers: {
+                    'Content-Length': Buffer.byteLength(reqPayload),
+                    'Content-Type': 'application/json',
+                    'Content-Version': `v${ghostVersion.safe}`
+                },
+                timeout: 2 * 1000,
+                retry: 5
+            };
+
+            logging.info(`Triggering webhook for "${webhook.get('event')}" with url "${url}"`);
+
+            await this.request(url, opts)
+                .then(response.onSuccess(webhook))
+                .catch(response.onError(webhook));
+        }
+    }
+}
+
+module.exports = WebhookTrigger;

package/core/server/update-check.js

@@ -1,6 +1,6 @@
 const _ = require('lodash');
 
-const api = require('./api');
+const api = require('./api').endpoints;
 const config = require('../shared/config');
 const urlUtils = require('./../shared/url-utils');
 const jobsService = require('./services/jobs');

package/core/server/web/admin/app.js

@@ -17,7 +17,7 @@ module.exports = function setupAdminApp() {
     // @TODO ensure this gets a local 404 error handler
     const configMaxAge = config.get('caching:admin:maxAge');
     adminApp.use('/assets', serveStatic(
-        config.get('paths').clientAssets,
+        config.get('paths').adminAssets,
         {maxAge: (configMaxAge || configMaxAge === 0) ? configMaxAge : constants.ONE_YEAR_MS, fallthrough: false}
     ));