ghost 5.115.0 → 5.116.0

package/core/frontend/services/assets-minification/Minifier.js

@@ -0,0 +1,191 @@
+/**
+ * ```
+ * const Minifier = require('./Minifier');
+ * const minifier = new Minifier({
+ *     src: 'my/src/path',
+ *     dest: 'my/dest/path'
+ * });
+ *
+ * minifier.minify({
+ *     'some.css': '*.css',
+ *     'then.js': '!(other).js'
+ * });
+ * ```
+ *
+ * - Minfier constructor requires a src and a dest
+ * - minify() function takes an object with destination file as the key and source glob as the value
+ *    - globs can be anything tiny-glob supports
+ *    - destination files must end with .css or .js
+ *    - src files will be minified according to their destination file extension
+ */
+
+const errors = require('@tryghost/errors');
+const debug = require('@tryghost/debug')('minifier');
+const tpl = require('@tryghost/tpl');
+const glob = require('tiny-glob');
+const path = require('path');
+const fs = require('fs').promises;
+const isWin = process.platform === 'win32';
+
+const messages = {
+    badDestination: {
+        message: 'Unexpected destination {dest}',
+        context: 'Minifier expected a destination that ended in .css or .js'
+    },
+    badSource: {
+        message: 'Unable to read source files {src}',
+        context: 'Minifier was unable to locate or read the source files'
+    },
+    missingConstructorOption: {
+        message: 'Minifier missing {opt} option',
+        context: 'new Minifier({}) requires a {opt} option'
+    },
+    globalHelp: 'Refer to the README for Minifier for how to use this module'
+};
+
+// public API for minify hooks
+class Minifier {
+    constructor({src, dest}) {
+        if (!src) {
+            throw new errors.IncorrectUsageError({
+                message: tpl(messages.missingConstructorOption.message, {opt: 'src'}),
+                context: tpl(messages.missingConstructorOption.context, {opt: 'src'}),
+                help: tpl(messages.globalHelp)
+            });
+        }
+        if (!dest) {
+            throw new errors.IncorrectUsageError({
+                message: tpl(messages.missingConstructorOption.message, {opt: 'dest'}),
+                context: tpl(messages.missingConstructorOption.context, {opt: 'dest'}),
+                help: tpl(messages.globalHelp)
+            });
+        }
+        this.srcPath = src;
+        this.destPath = dest;
+    }
+
+    getFullSrc(src) {
+        return path.join(this.srcPath, src);
+    }
+
+    getFullDest(dest) {
+        return path.join(this.destPath, dest);
+    }
+
+    async minifyCSS(contents) {
+        const csso = require('csso');
+        const result = await csso.minify(contents);
+        if (result && result.css) {
+            return result.css;
+        }
+        return null;
+    }
+
+    async minifyJS(contents) {
+        const terser = require('terser');
+        const result = await terser.minify(contents);
+        if (result && result.code) {
+            return result.code;
+        }
+        return null;
+    }
+
+    async getMatchingFiles(src) {
+        let fullSrc = this.getFullSrc(src);
+        if (isWin) {
+            fullSrc = fullSrc.replace(/\\/g,'/');
+        }
+        return await glob(fullSrc);
+    }
+
+    async readFiles(files) {
+        let mergedFiles = '';
+        for (const file of files) {
+            const contents = await fs.readFile(file, 'utf8');
+            mergedFiles += contents;
+        }
+
+        return mergedFiles;
+    }
+
+    async getSrcFileContents(src) {
+        try {
+            const files = await this.getMatchingFiles(src);
+
+            if (files) {
+                return await this.readFiles(files);
+            }
+        } catch (error) {
+            throw new errors.IncorrectUsageError({
+                message: tpl(messages.badSource.message, {src}),
+                context: tpl(messages.badSource.context),
+                help: tpl(messages.globalHelp)
+            });
+        }
+    }
+
+    async writeFile(contents, dest) {
+        if (contents) {
+            let writePath = this.getFullDest(dest);
+            // Ensure the output folder exists
+            await fs.mkdir(this.destPath, {recursive: true});
+            // Create the file
+            await fs.writeFile(writePath, contents);
+            return writePath;
+        }
+    }
+
+    /**
+     * Minify files
+     *
+     * @param {Object} globs An object in the form of
+     * ```js
+     * {
+     *     'destination1.js': 'glob/*.js',
+     *     'destination2.js': 'glob2/*.js'
+     * }
+     * ```
+     * @param {Object} [options]
+     * @param {Object} [options.replacements] Key value pairs that should get replaced in the content before minifying
+     * @returns {Promise<string[]>} List of minified files (keys of globs)
+     */
+    async minify(globs, options) {
+        debug('Begin', globs);
+        const destinations = Object.keys(globs);
+        const minifiedFiles = [];
+
+        for (const dest of destinations) {
+            const src = globs[dest];
+            let contents = await this.getSrcFileContents(src);
+
+            if (options?.replacements) {
+                for (const key of Object.keys(options.replacements)) {
+                    contents = contents.replace(key, options.replacements[key]);
+                }
+            }
+            let minifiedContents;
+
+            if (dest.endsWith('.css')) {
+                minifiedContents = await this.minifyCSS(contents);
+            } else if (dest.endsWith('.js')) {
+                minifiedContents = await this.minifyJS(contents);
+            } else {
+                throw new errors.IncorrectUsageError({
+                    message: tpl(messages.badDestination.message, {dest}),
+                    context: tpl(messages.badDestination.context),
+                    help: tpl(messages.globalHelp)
+                });
+            }
+
+            const result = await this.writeFile(minifiedContents, dest);
+            if (result) {
+                minifiedFiles.push(dest);
+            }
+        }
+
+        debug('End');
+        return minifiedFiles;
+    }
+}
+
+module.exports = Minifier;

package/core/frontend/services/routing/controllers/previews.js

@@ -19,7 +19,8 @@ module.exports = function previewController(req, res, next) {
     const params = {
         uuid: req.params.uuid,
         status: 'all',
-        include: 'authors,tags,tiers'
+        include: 'authors,tags,tiers',
+        member_status: req.query?.member_status
     };
 
     return api[res.routerOptions.query.controller]

package/core/frontend/src/cards/css/cta.css

@@ -95,7 +95,7 @@
 .kg-cta-content {
     display: flex;
     padding: 1.5em;
-    gap: 1.5em 1.5em 1.7em;
+    gap: 1.5em;
 }
 
 @media (max-width: 600px) {

package/core/server/adapters/cache/Redis.js

@@ -1,4 +1,4 @@
 /* eslint-disable ghost/filenames/match-regex */
-const RedisCache = require('@tryghost/adapter-cache-redis');
+const RedisCache = require('../lib/redis/AdapterCacheRedis');
 
 module.exports = RedisCache;

package/core/server/adapters/lib/redis/AdapterCacheRedis.js

@@ -0,0 +1,287 @@
+const BaseCacheAdapter = require('@tryghost/adapter-base-cache');
+const logging = require('@tryghost/logging');
+const metrics = require('@tryghost/metrics');
+const debug = require('@tryghost/debug')('redis-cache');
+const cacheManager = require('cache-manager');
+const redisStoreFactory = require('./redis-store-factory');
+const calculateSlot = require('cluster-key-slot');
+
+class AdapterCacheRedis extends BaseCacheAdapter {
+    /**
+     *
+     * @param {Object} config
+     * @param {Object} [config.cache] - caching instance compatible with cache-manager's redis store
+     * @param {String} [config.host] - redis host used in case no cache instance provided
+     * @param {Number} [config.port] - redis port used in case no cache instance provided
+     * @param {String} [config.password] - redis password used in case no cache instance provided
+     * @param {Object} [config.clusterConfig] - redis cluster config used in case no cache instance provided
+     * @param {Object} [config.storeConfig] - extra redis client config used in case no cache instance provided
+     * @param {Number} [config.ttl] - default cached value Time To Live (expiration) in *seconds*
+     * @param {Number} [config.getTimeoutMilliseconds] - default timeout for cache get operations in *milliseconds*
+     * @param {Number} [config.refreshAheadFactor] - 0-1 number to use to determine how old (as a percentage of ttl) an entry should be before refreshing it
+     * @param {String} [config.keyPrefix] - prefix to use when building a unique cache key, e.g.: 'some_id:image-sizes:'
+     * @param {Boolean} [config.reuseConnection] - specifies if the redis store/connection should be reused within the process
+     */
+    constructor(config) {
+        super();
+
+        this.cache = config.cache;
+
+        if (!this.cache) {
+            // @NOTE: this condition can be avoided if we add merging of nested options
+            //        to adapter configuration. Than adding adapter-specific {clusterConfig: {options: {ttl: XXX}}}
+            //        will be enough to set ttl for redis cluster.
+            if (config.ttl && config.clusterConfig) {
+                if (!config.clusterConfig.options) {
+                    config.clusterConfig.options = {};
+                }
+
+                config.clusterConfig.options.ttl = config.ttl;
+            }
+
+            const storeOptions = {
+                ttl: config.ttl,
+                host: config.host,
+                port: config.port,
+                username: config.username,
+                password: config.password,
+                retryStrategy: () => {
+                    return (config.storeConfig.retryConnectSeconds || 10) * 1000;
+                },
+                ...config.storeConfig,
+                clusterConfig: config.clusterConfig
+            };
+            const store = redisStoreFactory.getRedisStore(storeOptions, config.reuseConnection);
+
+            this.cache = cacheManager.caching({
+                store: store,
+                ...storeOptions
+            });
+        }
+
+        this.ttl = config.ttl;
+        this.refreshAheadFactor = config.refreshAheadFactor || 0;
+        this.getTimeoutMilliseconds = config.getTimeoutMilliseconds || null;
+        this.currentlyExecutingBackgroundRefreshes = new Set();
+        this.keyPrefix = config.keyPrefix;
+        this._keysPattern = config.keyPrefix ? `${config.keyPrefix}*` : '';
+        this.redisClient = this.cache.store.getClient();
+        this.redisClient.on('error', this.handleRedisError);
+    }
+
+    handleRedisError(error) {
+        logging.error(error);
+    }
+
+    #getPrimaryRedisNode() {
+        debug('getPrimaryRedisNode');
+        if (this.redisClient.constructor.name !== 'Cluster') {
+            return this.redisClient;
+        }
+        const slot = calculateSlot(this.keyPrefix);
+        const [ip, port] = this.redisClient.slots[slot][0].split(':');
+        for (const node of this.redisClient.nodes()) {
+            if (node.options.host === ip && node.options.port === parseInt(port)) {
+                return node;
+            }
+        }
+        return null;
+    }
+
+    #scanNodeForKeys(node) {
+        debug(`scanNodeForKeys matching ${this._keysPattern}`);
+        return new Promise((resolve, reject) => {
+            const stream = node.scanStream({match: this._keysPattern, count: 100});
+            let keys = [];
+            stream.on('data', (resultKeys) => {
+                keys = keys.concat(resultKeys);
+            });
+            stream.on('error', (e) => {
+                reject(e);
+            });
+            stream.on('end', () => {
+                resolve(keys);
+            });
+        });
+    }
+
+    async #getKeys() {
+        debug('#getKeys');
+        const primaryNode = this.#getPrimaryRedisNode();
+        if (primaryNode === null) {
+            return [];
+        }
+        return await this.#scanNodeForKeys(primaryNode);
+    }
+
+    /**
+     * This is a recommended way to build cache key prefixes from
+     * the cache-manager package. Might be a good contribution to make
+     * in the package itself (https://github.com/node-cache-manager/node-cache-manager/issues/158)
+     * @param {string} key
+     * @returns {string}
+     */
+    _buildKey(key) {
+        if (this.keyPrefix) {
+            return `${this.keyPrefix}${key}`;
+        }
+
+        return key;
+    }
+
+    /**
+     * This is a method to remove the key prefix from any raw key returned from redis.
+     * @param {string} key
+     * @returns {string}
+     */
+    _removeKeyPrefix(key) {
+        return key.slice(this.keyPrefix.length);
+    }
+
+    /**
+     *
+     * @param {String} internalKey
+     */
+    async shouldRefresh(internalKey) {
+        if (this.refreshAheadFactor === 0) {
+            debug(`shouldRefresh ${internalKey}: false - refreshAheadFactor = 0`);
+            return false;
+        }
+        if (this.refreshAheadFactor === 1) {
+            debug(`shouldRefresh ${internalKey}: true - refreshAheadFactor = 1`);
+            return true;
+        }
+        try {
+            const ttlRemainingForEntry = await this.cache.ttl(internalKey);
+            const shouldRefresh = ttlRemainingForEntry < this.refreshAheadFactor * this.ttl;
+            debug(`shouldRefresh ${internalKey}: ${shouldRefresh} - TTL remaining = ${ttlRemainingForEntry}`);
+            return shouldRefresh;
+        } catch (err) {
+            logging.error(err);
+            return false;
+        }
+    }
+
+    /**
+     * Returns the specified key from the cache if it exists, otherwise returns null
+     * - If getTimeoutMilliseconds is set, the method will return a promise that resolves with the value or null if the timeout is exceeded
+     * 
+     * @param {string} key 
+     */
+    async _get(key) {
+        if (typeof this.getTimeoutMilliseconds !== 'number') {
+            return this.cache.get(key);
+        } else {
+            return new Promise((resolve) => {
+                const timer = setTimeout(() => {
+                    debug('get', key, 'timeout');
+                    resolve(null);
+                }, this.getTimeoutMilliseconds);
+    
+                this.cache.get(key).then((result) => {
+                    clearTimeout(timer);
+                    resolve(result);
+                });
+            });
+        }
+    }
+
+    /**
+     *
+     * @param {string} key
+     * @param {() => Promise<any>} [fetchData] An optional function to fetch the data, which will be used in the case of a cache MISS or a background refresh
+     */
+    async get(key, fetchData) {
+        const internalKey = this._buildKey(key);
+        try {
+            const result = await this._get(internalKey);
+            debug(`get ${internalKey}: Cache ${result ? 'HIT' : 'MISS'}`);
+            if (!fetchData) {
+                return result;
+            }
+            if (result) {
+                const shouldRefresh = await this.shouldRefresh(internalKey);
+                const isRefreshing = this.currentlyExecutingBackgroundRefreshes.has(internalKey);
+                if (isRefreshing) {
+                    debug(`Background refresh already happening for ${internalKey}`);
+                }
+                if (!isRefreshing && shouldRefresh) {
+                    debug(`Doing background refresh for ${internalKey}`);
+                    this.currentlyExecutingBackgroundRefreshes.add(internalKey);
+                    fetchData().then(async (data) => {
+                        await this.set(key, data); // We don't use `internalKey` here because `set` handles it
+                        this.currentlyExecutingBackgroundRefreshes.delete(internalKey);
+                    }).catch((error) => {
+                        this.currentlyExecutingBackgroundRefreshes.delete(internalKey);
+                        logging.error({
+                            message: 'There was an error refreshing cache data in the background',
+                            error: error
+                        });
+                    });
+                }
+                return result;
+            } else {
+                const data = await fetchData();
+                await this.set(key, data); // We don't use `internalKey` here because `set` handles it
+                return data;
+            }
+        } catch (err) {
+            logging.error(err);
+        }
+    }
+
+    /**
+     *
+     * @param {String} key
+     * @param {*} value
+     */
+    async set(key, value) {
+        const internalKey = this._buildKey(key);
+        debug('set', internalKey);
+        try {
+            return await this.cache.set(internalKey, value);
+        } catch (err) {
+            logging.error(err);
+        }
+    }
+
+    /**
+     * Reset the cache by deleting everything from redis
+     */
+    async reset() {
+        debug('reset');
+        try {
+            const t0 = performance.now();
+            logging.debug(`[RedisAdapter] Clearing cache: scanning for keys matching ${this._keysPattern}`);
+            const keys = await this.#getKeys();
+            logging.debug(`[RedisAdapter] Clearing cache: found ${keys.length} keys matching ${this._keysPattern} in ${(performance.now() - t0).toFixed(1)}ms`);
+            metrics.metric('cache-reset-scan', (performance.now() - t0).toFixed(1));
+            const t1 = performance.now();
+            for (const key of keys) {
+                await this.cache.del(key);
+            }
+            logging.debug(`[RedisAdapter] Clearing cache: deleted ${keys.length} keys matching ${this._keysPattern} in ${(performance.now() - t1).toFixed(1)}ms`);
+            metrics.metric('cache-reset-delete', (performance.now() - t1).toFixed(1));
+            metrics.metric('cache-reset', (performance.now() - t0).toFixed(1));
+            metrics.metric('cache-reset-key-count', keys.length);
+        } catch (err) {
+            logging.error(err);
+        }
+    }
+
+    /**
+     * Helper method to assist "getAll" type of operations
+     * @returns {Promise<Array<String>>} all keys present in the cache
+     */
+    async keys() {
+        try {
+            return (await this.#getKeys()).map((key) => {
+                return this._removeKeyPrefix(key);
+            });
+        } catch (err) {
+            logging.error(err);
+        }
+    }
+}
+
+module.exports = AdapterCacheRedis;

package/core/server/adapters/lib/redis/redis-store-factory.js

@@ -0,0 +1,22 @@
+const defaultCacheManager = require('cache-manager-ioredis');
+let redisStoreSingletonInstance;
+
+/**
+ *
+ * @param {object} [storeOptions] options to pass to the Redis store instance
+ * @param {boolean} [reuseConnection] specifies if the Redis store/connection should be reused within the process
+* @param {object} [CacheManager] CacheManager constructor to instantiate, defaults to cache-manager-ioredis
+ */
+const getRedisStore = (storeOptions, reuseConnection = true, CacheManager = defaultCacheManager) => {
+    if (storeOptions && reuseConnection) {
+        if (!redisStoreSingletonInstance) {
+            redisStoreSingletonInstance = CacheManager.create(storeOptions);
+        }
+
+        return redisStoreSingletonInstance;
+    } else {
+        return CacheManager;
+    }
+};
+
+module.exports.getRedisStore = getRedisStore;

package/core/server/api/endpoints/posts.js

@@ -30,10 +30,16 @@ function getCacheHeaderFromEventString(event, dto) {
         return true;
     }
     if (event === 'scheduled_updated' || event === 'draft_updated') {
+        const baseUrl = urlUtils.urlFor({
+            relativeUrl: urlUtils.urlJoin('/p', dto.uuid, '/')
+        });
         return {
-            value: urlUtils.urlFor({
-                relativeUrl: urlUtils.urlJoin('/p', dto.uuid, '/')
-            })
+            value: [
+                baseUrl,
+                `${baseUrl}?member_status=anonymous`,
+                `${baseUrl}?member_status=free`,
+                `${baseUrl}?member_status=paid`
+            ].join(', ')
         };
     }
 }

package/core/server/api/endpoints/previews.js

@@ -2,11 +2,39 @@ const tpl = require('@tryghost/tpl');
 const errors = require('@tryghost/errors');
 const models = require('../../models');
 const ALLOWED_INCLUDES = ['authors', 'tags'];
+const ALLOWED_MEMBER_STATUSES = ['anonymous', 'free', 'paid'];
 
 const messages = {
     postNotFound: 'Post not found.'
 };
 
+// Simulate serving content as different member states by setting the minimal
+// member context needed for content gating to function
+const _addMemberContextToFrame = (frame) => {
+    if (!frame?.options?.member_status) {
+        return;
+    }
+
+    // only set apiType when given a member_status to preserve backwards compatibility
+    // where we used to serve "Admin API" content with no gating for all previews
+    frame.apiType = 'content';
+
+    frame.original ??= {};
+    frame.original.context ??= {};
+
+    if (frame.options?.member_status === 'free') {
+        frame.original.context.member = {
+            status: 'free'
+        };
+    }
+
+    if (frame.options?.member_status === 'paid') {
+        frame.original.context.member = {
+            status: 'paid'
+        };
+    }
+};
+
 /** @type {import('@tryghost/api-framework').Controller} */
 const controller = {
     docName: 'previews',
@@ -17,7 +45,8 @@ const controller = {
         },
         permissions: true,
         options: [
-            'include'
+            'include',
+            'member_status'
         ],
         data: [
             'uuid'
@@ -26,6 +55,9 @@ const controller = {
             options: {
                 include: {
                     values: ALLOWED_INCLUDES
+                },
+                member_status: {
+                    values: ALLOWED_MEMBER_STATUSES
                 }
             },
             data: {
@@ -35,6 +67,8 @@ const controller = {
             }
         },
         query(frame) {
+            _addMemberContextToFrame(frame);
+
             return models.Post.findOne(Object.assign({status: 'all'}, frame.data), frame.options)
                 .then((model) => {
                     if (!model) {

package/core/server/api/endpoints/slugs.js

@@ -21,7 +21,8 @@ const controller = {
         },
         options: [
             'include',
-            'type'
+            'type',
+            'id'
         ],
         data: [
             'name'
@@ -32,6 +33,9 @@ const controller = {
                 type: {
                     required: true,
                     values: Object.keys(allowedTypes)
+                },
+                id: {
+                    required: false
                 }
             },
             data: {
@@ -41,7 +45,7 @@ const controller = {
             }
         },
         query(frame) {
-            return models.Base.Model.generateSlug(allowedTypes[frame.options.type], frame.data.name, {status: 'all'})
+            return models.Base.Model.generateSlug(allowedTypes[frame.options.type], frame.data.name, {status: 'all', modelId: frame.options.id})
                 .then((slug) => {
                     if (!slug) {
                         return Promise.reject(new errors.InternalServerError({

package/core/server/api/endpoints/utils/serializers/output/utils/post-gating.js

@@ -8,7 +8,7 @@ const {PERMIT_ACCESS} = membersService.contentGating;
 const HAS_GATED_BLOCKS_REGEX = /<!--\s*kg-gated-block:begin/;
 // Match gated block comments
 // e.g. <!--kg-gated-block:begin nonMember:true memberSegment:"status:free"-->...gated content<!--kg-gated-block:end-->
-const GATED_BLOCK_REGEX = /<!--\s*kg-gated-block:begin\s+([^\n]+?)\s*-->\s*([\s\S]*?)\s*<!--\s*kg-gated-block:end\s*-->/g;
+const GATED_BLOCK_REGEX = /<!--kg-gated-block:begin ([^\n]+?)\s*-->([\s\S]*?)<!--kg-gated-block:end-->/g;
 // Match the key-value pairs (with optional quotes around the value) in the gated-block:begin comment
 const GATED_BLOCK_PARAM_REGEX = /\b(?<key>\w+):["']?(?<value>[^"'\s]+)["']?/g;
 
@@ -70,15 +70,14 @@ const stripGatedBlocks = function (html, member) {
     });
 };
 
-function _updatePlaintext(attrs) {
+function _updateTextAttrs(attrs) {
     if (attrs.html) {
         attrs.plaintext = htmlToPlaintext.excerpt(attrs.html);
     }
-}
 
-function _updateExcerpt(attrs) {
     if (!attrs.custom_excerpt && attrs.excerpt) {
-        attrs.excerpt = htmlToPlaintext.excerpt(attrs.html).substring(0, 500);
+        const plaintext = attrs.plaintext || htmlToPlaintext.excerpt(attrs.html);
+        attrs.excerpt = plaintext.substring(0, 500);
     }
 }
 
@@ -96,8 +95,7 @@ const forPost = (attrs, frame) => {
 
         if (paywallIndex !== -1) {
             attrs.html = attrs.html.slice(0, paywallIndex);
-            _updatePlaintext(attrs);
-            _updateExcerpt(attrs);
+            _updateTextAttrs(attrs);
         } else {
             ['plaintext', 'html', 'excerpt'].forEach((field) => {
                 if (attrs[field] !== undefined) {
@@ -111,8 +109,7 @@ const forPost = (attrs, frame) => {
         const hasGatedBlocks = HAS_GATED_BLOCKS_REGEX.test(attrs.html);
         if (hasGatedBlocks) {
             attrs.html = module.exports.stripGatedBlocks(attrs.html, frame.original.context.member);
-            _updatePlaintext(attrs);
-            _updateExcerpt(attrs);
+            _updateTextAttrs(attrs);
         }
     }