ghost 5.115.1 → 5.116.0

package/core/server/data/seeders/utils/event-generator.js

@@ -0,0 +1,48 @@
+const probabilityDistributions = require('probability-distributions');
+
+const generateEvents = ({
+    shape = 'flat',
+    trend = 'positive',
+    total = 0,
+    startTime = new Date(),
+    endTime = new Date()
+} = {}) => {
+    if (total <= 0) {
+        return [];
+    }
+
+    let alpha = 0;
+    let beta = 0;
+    let positiveTrend = trend === 'positive';
+    switch (shape) {
+    case 'linear':
+        alpha = 2;
+        beta = 1;
+        break;
+    case 'ease-in':
+        alpha = 4;
+        beta = 1;
+        break;
+    case 'ease-out':
+        alpha = 1;
+        beta = 4;
+        positiveTrend = !positiveTrend;
+        break;
+    case 'flat':
+        alpha = 1;
+        beta = 1;
+        break;
+    }
+
+    const data = probabilityDistributions.rbeta(total, alpha, beta, 0);
+    const startTimeValue = startTime.valueOf();
+    const timeDifference = endTime.valueOf() - startTimeValue;
+    return data.map((x) => {
+        if (!positiveTrend) {
+            x = 1 - x;
+        }
+        return new Date(startTimeValue + timeDifference * x);
+    });
+};
+
+module.exports = generateEvents;

package/core/server/data/seeders/utils/random.js

@@ -0,0 +1,13 @@
+const {faker} = require('@faker-js/faker');
+
+/**
+ * Adds another degree of randomness into some decisions
+ * @param {number} lowerThan Only this % of people will achieve this luck
+ * @returns {boolean} Whether this person is lucky enough for the condition
+ */
+const luck = lowerThan => faker.datatype.number({
+    min: 1,
+    max: 100
+}) <= lowerThan;
+
+module.exports = {luck};

package/core/server/data/seeders/utils/topological-sort.js

@@ -0,0 +1,33 @@
+/**
+ * This sorting algorithm is used to make sure that dependent tables are imported after their dependencies.
+ * @param {Array<Object>} objects Objects with a name and dependencies properties
+ * @returns Topologically sorted array of objects
+ */
+module.exports = function topologicalSort(objects) {
+    // Create an empty result array to store the ordered objects
+    const result = [];
+    // Create a set to track visited objects during the DFS
+    const visited = new Set();
+
+    // Helper function to perform DFS
+    function dfs(name) {
+        if (visited.has(name)) {
+            return;
+        }
+
+        visited.add(name);
+        const dependencies = objects.find(item => item.name === name)?.dependencies || [];
+        for (const dependency of dependencies) {
+            dfs(dependency);
+        }
+
+        result.push(objects.find(item => item.name === name));
+    }
+
+    // Perform DFS on each object
+    for (const object of objects) {
+        dfs(object.name);
+    }
+
+    return result;
+};

package/core/server/services/adapter-manager/AdapterManager.js

@@ -0,0 +1,161 @@
+const path = require('path');
+const errors = require('@tryghost/errors');
+
+/**
+ * @typedef { function(new: Adapter, object) } AdapterConstructor
+ */
+
+/**
+ * @typedef {object} Adapter
+ * @prop {string[]} requiredFns
+ */
+
+module.exports = class AdapterManager {
+    /**
+     * @param {object} config
+     * @param {string[]} config.pathsToAdapters The paths to check, e.g. ['content/adapters', 'core/server/adapters']
+     * @param {(path: string) => AdapterConstructor} config.loadAdapterFromPath A function to load adapters, e.g. global.require
+     */
+    constructor({pathsToAdapters, loadAdapterFromPath}) {
+        /**
+         * @private
+         * @type {Object.<string, AdapterConstructor>}
+         */
+        this.baseClasses = {};
+
+        /**
+         * @private
+         * @type {Object.<string, Object.<string, Adapter>>}
+         */
+        this.instanceCache = {};
+
+        /**
+         * @private
+         * @type {string[]}
+         */
+        this.pathsToAdapters = pathsToAdapters;
+
+        /**
+         * @private
+         * @type {(path: string) => AdapterConstructor}
+         */
+        this.loadAdapterFromPath = loadAdapterFromPath;
+    }
+
+    /**
+     * Register an adapter type and the corresponding base class. Must be called before requesting adapters of that type
+     *
+     * @param {string} type The name for the type of adapter
+     * @param {AdapterConstructor} BaseClass The class from which all adapters of this type must extend
+     */
+    registerAdapter(type, BaseClass) {
+        this.instanceCache[type] = {};
+        this.baseClasses[type] = BaseClass;
+    }
+
+    /**
+     * Force recreation of all instances instead of reusing cached instances. Use when editing config file during tests.
+     */
+    clearInstanceCache() {
+        for (const key of Object.keys(this.instanceCache)) {
+            this.instanceCache[key] = {};
+        }
+    }
+
+    /**
+     * getAdapter
+     *
+     * @param {string} adapterName The name of the type of adapter, e.g. "storage" or "scheduling", optionally including the feature, e.g. "storage:files"
+     * @param {string} adapterClassName The active adapter instance class name e.g. "LocalFileStorage"
+     * @param {object} [config] The config the adapter could be instantiated with
+     *
+     * @returns {Adapter} The resolved and instantiated adapter
+     */
+    getAdapter(adapterName, adapterClassName, config) {
+        if (!adapterName || !adapterClassName) {
+            throw new errors.IncorrectUsageError({
+                message: 'getAdapter must be called with a adapterName and a adapterClassName.'
+            });
+        }
+
+        let adapterType;
+        if (adapterName.includes(':')) {
+            [adapterType] = adapterName.split(':');
+        } else {
+            adapterType = adapterName;
+        }
+
+        const adapterCache = this.instanceCache[adapterType];
+
+        if (!adapterCache) {
+            throw new errors.NotFoundError({
+                message: `Unknown adapter type ${adapterType}. Please register adapter.`
+            });
+        }
+
+        // @NOTE: example cache key value 'email:newsletters:custom-newsletter-adapter'
+        const adapterCacheKey = `${adapterName}:${adapterClassName}`;
+        if (adapterCache[adapterCacheKey]) {
+            return adapterCache[adapterCacheKey];
+        }
+
+        /** @type AdapterConstructor */
+        let Adapter;
+        for (const pathToAdapters of this.pathsToAdapters) {
+            const pathToAdapter = path.join(pathToAdapters, adapterType, adapterClassName);
+            try {
+                Adapter = this.loadAdapterFromPath(pathToAdapter);
+                if (Adapter) {
+                    break;
+                }
+            } catch (err) {
+                // Catch runtime errors
+                if (err.code !== 'MODULE_NOT_FOUND') {
+                    throw new errors.IncorrectUsageError({err});
+                }
+
+                // Catch missing dependencies BUT NOT missing adapter
+                if (!err.message.includes(pathToAdapter)) {
+                    throw new errors.IncorrectUsageError({
+                        message: `You are missing dependencies in your adapter ${pathToAdapter}`,
+                        err
+                    });
+                }
+            }
+        }
+
+        if (!Adapter) {
+            throw new errors.IncorrectUsageError({
+                message: `Unable to find ${adapterType} adapter ${adapterClassName} in ${this.pathsToAdapters}.`
+            });
+        }
+
+        const adapter = new Adapter(config);
+
+        if (!(adapter instanceof this.baseClasses[adapterType])) {
+            if (Object.getPrototypeOf(Adapter).name !== this.baseClasses[adapterType].name) {
+                throw new errors.IncorrectUsageError({
+                    message: `${adapterType} adapter ${adapterClassName} does not inherit from the base class.`
+                });
+            }
+        }
+
+        if (!adapter.requiredFns) {
+            throw new errors.IncorrectUsageError({
+                message: `${adapterType} adapter ${adapterClassName} does not have the requiredFns.`
+            });
+        }
+
+        for (const requiredFn of adapter.requiredFns) {
+            if (typeof adapter[requiredFn] !== 'function') {
+                throw new errors.IncorrectUsageError({
+                    message: `${adapterType} adapter ${adapterClassName} is missing the ${requiredFn} method.`
+                });
+            }
+        }
+
+        adapterCache[adapterCacheKey] = adapter;
+
+        return adapter;
+    }
+};

package/core/server/services/adapter-manager/index.js

@@ -1,4 +1,4 @@
-const AdapterManager = require('@tryghost/adapter-manager');
+const AdapterManager = require('./AdapterManager');
 const getAdapterServiceConfig = require('./config');
 const resolveAdapterOptions = require('./options-resolver');
 const config = require('../../../shared/config');

package/core/server/services/announcement-bar-service/AnnouncementBarSettings.js

@@ -0,0 +1,54 @@
+const AnnouncementVisibilityValues = require('./AnnouncementVisibilityValues');
+
+class AnnouncementBarSettings {
+    #getAnnouncementSettings;
+
+    static VisibilityValues = AnnouncementVisibilityValues;
+
+    /**
+     *
+     * @param {Object} deps
+     * @param {() => {announcement: string, announcement_visibility: string[], announcement_background: string}} deps.getAnnouncementSettings
+     */
+    constructor(deps) {
+        this.#getAnnouncementSettings = deps.getAnnouncementSettings;
+    }
+
+    /**
+     * @param {Object} [member]
+     * @param {string} member.status
+     * @returns {{announcement: string, announcement_background: string}}
+     */
+    getAnnouncementSettings(member) {
+        let announcement = undefined;
+
+        // NOTE: combination of 'free_members' & 'paid_members' makes just a 'members' filter
+        const announcementSettings = this.#getAnnouncementSettings();
+
+        if (announcementSettings.announcement) {
+            const visibilities = announcementSettings.announcement_visibility;
+            const announcementContent = announcementSettings.announcement;
+
+            if (visibilities.length === 0) {
+                announcement = undefined;
+            } else {
+                if (visibilities.includes(AnnouncementVisibilityValues.VISITORS) && !member) {
+                    announcement = announcementContent;
+                } else if (visibilities.includes(AnnouncementVisibilityValues.FREE_MEMBERS) && (member?.status === 'free')) {
+                    announcement = announcementContent;
+                } else if (visibilities.includes(AnnouncementVisibilityValues.PAID_MEMBERS) && (member && member.status !== 'free')) {
+                    announcement = announcementContent;
+                }
+            }
+        }
+
+        if (announcement !== undefined) {
+            return {
+                announcement,
+                announcement_background: announcementSettings.announcement_background
+            };
+        }
+    }
+}
+
+module.exports = AnnouncementBarSettings;

package/core/server/services/announcement-bar-service/AnnouncementVisibilityValues.js

@@ -0,0 +1,11 @@
+// Available visibilities:
+// 'visitors' - anonymous visitors
+// 'free_members' - free members
+// 'paid_members' - paid members (aka non-free members)
+class AnnouncementVisibilityValues {
+    static VISITORS = 'visitors';
+    static FREE_MEMBERS = 'free_members';
+    static PAID_MEMBERS = 'paid_members';
+}
+
+module.exports = AnnouncementVisibilityValues;

package/core/server/services/announcement-bar-service/index.js

@@ -1,5 +1,5 @@
 const settingsCache = require('../../../shared/settings-cache');
-const AnnouncementBarSettings = require('@tryghost/announcement-bar-settings');
+const AnnouncementBarSettings = require('./AnnouncementBarSettings');
 
 const announcementBarService = new AnnouncementBarSettings({
     getAnnouncementSettings: () => ({

package/core/server/services/api-version-compatibility/APIVersionCompatibilityService.js

@@ -1,6 +1,6 @@
 const path = require('path');
 const VersionNotificationsDataService = require('./VersionNotificationsDataService');
-const EmailContentGenerator = require('@tryghost/email-content-generator');
+const EmailContentGenerator = require('../lib/EmailContentGenerator');
 
 class APIVersionCompatibilityService {
     /**

package/core/server/services/auth/session/session-service.js

@@ -46,6 +46,7 @@ totp.options = {
  * @prop {(req: Req, res: Res) => Promise<void>} sendAuthCodeToUser
  * @prop {(req: Req, res: Res) => Promise<boolean>} verifyAuthCodeForUser
  * @prop {(req: Req, res: Res) => Promise<boolean>} isVerifiedSession
+ * @prop {() => boolean} isVerificationRequired
  */
 
 /**
@@ -53,7 +54,7 @@ totp.options = {
  * @param {(req: Req, res: Res) => Promise<Session>} deps.getSession
  * @param {(data: {id: string}) => Promise<User>} deps.findUserById
  * @param {(req: Req) => string} deps.getOriginOfRequest
- * @param {(key: string) => string} deps.getSettingsCache
+ * @param {(key: 'require_email_mfa' | 'admin_session_secret' | 'title') => boolean | string} deps.getSettingsCache
  * @param {() => string} deps.getBlogLogo
  * @param {import('../../core/core/server/services/mail').GhostMailer} deps.mailer
  * @param {import('../../core/core/shared/labs')} deps.labs
@@ -96,6 +97,15 @@ module.exports = function createSessionService({
         }
     }
 
+    /**
+     * isVerificationRequired
+     * Determines if 2FA verification is required based on site settings
+     * @returns {boolean}
+     */
+    function isVerificationRequired() {
+        return getSettingsCache('require_email_mfa') === true;
+    }
+
     /**
      * createSessionForUser
      *
@@ -261,7 +271,7 @@ module.exports = function createSessionService({
             siteLogo: siteLogo,
             token: token,
             deviceDetails: await getDeviceDetails(session.user_agent, session.ip),
-            is2FARequired: getSettingsCache('require_email_mfa')
+            is2FARequired: this.isVerificationRequired()
         });
 
         try {
@@ -310,8 +320,7 @@ module.exports = function createSessionService({
     async function removeUserForSession(req, res) {
         const session = await getSession(req, res);
 
-        const requireMfa = getSettingsCache('require_email_mfa');
-        if (requireMfa) {
+        if (this.isVerificationRequired()) {
             session.verified = undefined;
         }
 
@@ -359,6 +368,7 @@ module.exports = function createSessionService({
         isVerifiedSession,
         sendAuthCodeToUser,
         verifyAuthCodeForUser,
-        generateAuthCodeForUser
+        generateAuthCodeForUser,
+        isVerificationRequired
     };
 };

package/core/server/services/custom-redirects/index.js

@@ -1,7 +1,7 @@
 const config = require('../../../shared/config');
 const urlUtils = require('../../../shared/url-utils');
 
-const DynamicRedirectManager = require('@tryghost/express-dynamic-redirects');
+const DynamicRedirectManager = require('../lib/DynamicRedirectManager');
 const CustomRedirectsAPI = require('./CustomRedirectsAPI');
 const validation = require('./validation');
 const {getBackupRedirectsFilePath} = require('./utils');

package/core/server/services/email-analytics/EmailAnalyticsProviderMailgun.js

@@ -1,4 +1,4 @@
-const MailgunClient = require('@tryghost/mailgun-client');
+const MailgunClient = require('../lib/MailgunClient');
 
 const DEFAULT_EVENT_FILTER = 'delivered OR opened OR failed OR unsubscribed OR complained';
 const PAGE_LIMIT = 300;

package/core/server/services/email-service/EmailServiceWrapper.js

@@ -17,7 +17,7 @@ class EmailServiceWrapper {
 
         const {EmailService, EmailController, EmailRenderer, SendingService, BatchSendingService, EmailSegmenter, MailgunEmailProvider} = require('@tryghost/email-service');
         const {Post, Newsletter, Email, EmailBatch, EmailRecipient, Member} = require('../../models');
-        const MailgunClient = require('@tryghost/mailgun-client');
+        const MailgunClient = require('../lib/MailgunClient');
         const configService = require('../../../shared/config');
         const settingsCache = require('../../../shared/settings-cache');
         const settingsHelpers = require('../settings-helpers');
@@ -53,7 +53,7 @@ class EmailServiceWrapper {
         });
         const i18nLanguage = labs.isSet('i18n') ? settingsCache.get('locale') || 'en' : 'en';
         const i18n = i18nLib(i18nLanguage, 'newsletter');
-        
+
         events.on('settings.labs.edited', () => {
             if (labs.isSet('i18n')) {
                 debug('labs i18n enabled, updating i18n to', settingsCache.get('locale'));
@@ -63,12 +63,12 @@ class EmailServiceWrapper {
                 i18n.changeLanguage('en');
             }
         });
-    
+
         events.on('settings.locale.edited', (model) => {
             if (labs.isSet('i18n')) {
                 debug('locale changed, updating i18n to', model.get('value'));
                 i18n.changeLanguage(model.get('value'));
-            } 
+            }
         });
 
         const mailgunEmailProvider = new MailgunEmailProvider({

package/core/server/services/email-suppression-list/MailgunEmailSuppressionList.js

@@ -1,5 +1,5 @@
 const {AbstractEmailSuppressionList, EmailSuppressionData, EmailSuppressedEvent} = require('@tryghost/email-suppression-list');
-const {SpamComplaintEvent, EmailBouncedEvent} = require('@tryghost/email-events');
+const {SpamComplaintEvent, EmailBouncedEvent} = require('@tryghost/email-service');
 const DomainEvents = require('@tryghost/domain-events');
 const logging = require('@tryghost/logging');
 const models = require('../../models');

package/core/server/services/email-suppression-list/service.js

@@ -1,7 +1,7 @@
-const MailgunClient = require('@tryghost/mailgun-client');
 const models = require('../../models');
 const configService = require('../../../shared/config');
 const settingsCache = require('../../../shared/settings-cache');
+const MailgunClient = require('../lib/MailgunClient');
 const MailgunEmailSuppressionList = require('./MailgunEmailSuppressionList');
 
 const mailgunClient = new MailgunClient({

package/core/server/services/lib/DynamicRedirectManager.js

@@ -0,0 +1,156 @@
+const express = require('express');
+const {parse: parseURL, format: formatURL} = require('url');
+const {parse: parseQuerystring, stringify: formatQuerystring} = require('querystring');
+
+class DynamicRedirectManager {
+    /**
+     * @param {object} config
+     * @param {number} config.permanentMaxAge
+     * @param {function} config.getSubdirectoryURL
+     */
+    constructor({permanentMaxAge, getSubdirectoryURL}) {
+        /** @private */
+        this.permanentMaxAge = permanentMaxAge;
+
+        this.getSubdirectoryURL = getSubdirectoryURL;
+
+        /** @private */
+        this.router = express.Router();
+        /** @private @type {Object.<string, {fromRegex: RegExp, to: string, options: {permanent: boolean}}>} */
+        this.redirects = {};
+
+        this.handleRequest = this.handleRequest.bind(this);
+    }
+
+    /**
+     * @private
+     * @param {string} string
+     * @returns {RegExp}
+     */
+    buildRegex(string) {
+        let flags = '';
+
+        if (string.startsWith('/') && string.endsWith('/i')) {
+            string = string.slice(1, -2);
+            flags += 'i';
+        }
+
+        if (string.endsWith('/')) {
+            string = string.slice(0, -1);
+        }
+
+        if (!string.endsWith('$')) {
+            string += '/?$';
+        }
+
+        return new RegExp(string, flags);
+    }
+
+    /**
+     * @private
+     * @param {string} redirectId
+     * @returns {void}
+     */
+    setupRedirect(redirectId) {
+        const {fromRegex, to, options: {permanent}} = this.redirects[redirectId];
+
+        this.router.get(fromRegex, (req, res) => {
+            const maxAge = permanent ? this.permanentMaxAge : 0;
+            const toURL = parseURL(to);
+            const toURLParams = parseQuerystring(toURL.query);
+            const currentURL = parseURL(req.url);
+            const currentURLParams = parseQuerystring(currentURL.query);
+            const params = Object.assign({}, currentURLParams, toURLParams);
+            const search = formatQuerystring(params);
+
+            toURL.pathname = currentURL.pathname.replace(fromRegex, toURL.pathname);
+            toURL.search = search !== '' ? `?${search}` : null;
+
+            /**
+             * Only if the url is internal should we prepend the Ghost subdirectory
+             * @see https://github.com/TryGhost/Ghost/issues/10776
+             */
+            if (!toURL.hostname) {
+                toURL.pathname = this.getSubdirectoryURL(toURL.pathname);
+            }
+
+            res.set({
+                'Cache-Control': `public, max-age=${maxAge}`
+            });
+
+            res.redirect(permanent ? 301 : 302, formatURL(toURL));
+        });
+    }
+
+    /**
+     * @param {string} from
+     * @param {string} to
+     * @param {object} [options]
+     * @param {boolean} [options.permanent]
+     *
+     * @returns {string} The redirect ID
+     */
+    addRedirect(from, to, options = {}) {
+        try {
+            // encode "from" only if it's not a regex
+            try {
+                new RegExp(from);
+            } catch (e) {
+                from = encodeURI(from);
+            }
+
+            const fromRegex = this.buildRegex(from);
+            const redirectId = from;
+            
+            this.redirects[redirectId] = {
+                fromRegex,
+                to,
+                options
+            };
+
+            this.setupRedirect(redirectId);
+
+            return redirectId;
+        } catch (error) {
+            if (error.message.match(/Invalid regular expression/gi)) {
+                return null;
+            }
+
+            throw error;
+        }
+    }
+
+    /**
+     * @param {string} redirectId
+     * @returns {void}
+     */
+    removeRedirect(redirectId) {
+        delete this.redirects[redirectId];
+
+        this.router = express.Router();
+        Object.keys(this.redirects).forEach(id => this.setupRedirect(id));
+
+        return;
+    }
+
+    /**
+     * @returns {void}
+     */
+    removeAllRedirects() {
+        this.redirects = {};
+        this.router = express.Router();
+    }
+
+    /**
+     * @param {express.Request} req
+     * @param {express.Response} res
+     * @param {express.NextFunction} next
+     *
+     * @returns {void}
+     */
+    handleRequest(req, res, next) {
+        this.router(req, res, next);
+    }
+}
+
+module.exports = DynamicRedirectManager;