ghost 5.115.0 → 5.116.0

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/explore-ping/ExplorePingService.js

@@ -0,0 +1,106 @@
+module.exports = class ExplorePingService {
+    /**
+     * @param {object} deps
+     * @param {{getPublic: () => import('../../../shared/settings-cache/CacheManager').PublicSettingsCache}} deps.settingsCache
+     * @param {object} deps.config
+     * @param {object} deps.labs
+     * @param {object} deps.logging
+     * @param {object} deps.ghostVersion
+     * @param {object} deps.request
+     * @param {{stats: {
+     *   getMostRecentlyPublishedPostDate: () => Promise<Date>,
+     *   getFirstPublishedPostDate: () => Promise<Date>,
+     *   getTotalPostsPublished: () => Promise<number>
+     * }}} deps.posts
+     * @param {{stats: {
+     *   getTotalMembers: () => Promise<number>
+     * }}} deps.members
+     */
+    constructor({settingsCache, config, labs, logging, ghostVersion, request, posts, members}) {
+        this.settingsCache = settingsCache;
+        this.config = config;
+        this.labs = labs;
+        this.logging = logging;
+        this.ghostVersion = ghostVersion;
+        this.request = request;
+        this.posts = posts;
+        this.members = members;
+    }
+
+    async constructPayload() {
+        /* eslint-disable camelcase */
+        const {title, description, icon, locale, accent_color, twitter, facebook} = this.settingsCache.getPublic();
+
+        // Get post statistics
+        const [totalPosts, lastPublishedAt, firstPublishedAt] = await Promise.all([
+            this.posts.stats.getTotalPostsPublished(),
+            this.posts.stats.getMostRecentlyPublishedPostDate(),
+            this.posts.stats.getFirstPublishedPostDate()
+        ]);
+
+        // Get member statistics with error handling
+        let totalMembers = null;
+        try {
+            totalMembers = await this.members.stats.getTotalMembers();
+        } catch (err) {
+            this.logging.warn('Failed to fetch member statistics', {
+                error: err.message,
+                context: 'explore-ping-service'
+            });
+            // Continue without member statistics
+        }
+
+        return {
+            ghost: this.ghostVersion.full,
+            url: this.config.get('url'),
+            title,
+            description,
+            icon,
+            locale,
+            accent_color,
+            twitter,
+            facebook,
+            posts_first: firstPublishedAt ? firstPublishedAt.toISOString() : null,
+            posts_last: lastPublishedAt ? lastPublishedAt.toISOString() : null,
+            posts_total: totalPosts,
+            members_total: totalMembers
+        };
+        /* eslint-enable camelcase */
+    }
+
+    async makeRequest(exploreUrl, payload) {
+        const json = JSON.stringify(payload);
+        this.logging.info('Pinging Explore with Payload', exploreUrl, json);
+
+        try {
+            const response = await this.request(exploreUrl, {
+                method: 'POST',
+                body: json,
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            this.logging.info('Explore Response', response.statusCode, response.statusMessage);
+
+            return response;
+        } catch (err) {
+            this.logging.warn('Explore Error', err.message);
+        }
+    }
+
+    async ping() {
+        if (!this.labs.isSet('explore')) {
+            return;
+        }
+
+        const exploreUrl = this.config.get('explore:url');
+        if (!exploreUrl) {
+            this.logging.warn('Explore URL not set');
+            return;
+        }
+
+        const payload = await this.constructPayload();
+        await this.makeRequest(exploreUrl, payload);
+    }
+};

package/core/server/services/explore-ping/index.js

@@ -0,0 +1,31 @@
+const ExplorePingService = require('./ExplorePingService');
+const config = require('../../../shared/config');
+const labs = require('../../../shared/labs');
+const logging = require('@tryghost/logging');
+const ghostVersion = require('@tryghost/version');
+const request = require('@tryghost/request');
+const settingsCache = require('../../../shared/settings-cache');
+const posts = require('../posts/posts-service');
+const members = require('../members');
+
+// Export the creation function for testing
+module.exports.createService = function createService() {
+    return new ExplorePingService({
+        settingsCache,
+        config,
+        labs,
+        logging,
+        ghostVersion,
+        request,
+        posts: posts(),
+        members
+    });
+};
+
+module.exports.init = async function init() {
+    const explorePingService = module.exports.createService();
+
+    // The final intention is to have this run on a schedule
+    // For the initial version, we'll just ping when the server starts
+    await explorePingService.ping();
+};

package/core/server/services/identity-tokens/IdentityTokenService.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityTokenService = void 0;
+const jsonwebtoken_1 = require("jsonwebtoken");
+class IdentityTokenService {
+    privateKey;
+    issuer;
+    keyId;
+    constructor(privateKey, issuer, keyId) {
+        this.privateKey = privateKey;
+        this.issuer = issuer;
+        this.keyId = keyId;
+    }
+    async getTokenForUser(email, role) {
+        const claims = {
+            sub: email
+        };
+        if (typeof role === 'string') {
+            claims.role = role;
+        }
+        const token = (0, jsonwebtoken_1.sign)(claims, this.privateKey, {
+            issuer: this.issuer,
+            expiresIn: '5m',
+            algorithm: 'RS256',
+            keyid: this.keyId
+        });
+        return token;
+    }
+}
+exports.IdentityTokenService = IdentityTokenService;

package/core/server/services/identity-tokens/IdentityTokenService.ts

@@ -0,0 +1,28 @@
+import {sign} from 'jsonwebtoken';
+
+export class IdentityTokenService {
+    constructor(
+        private privateKey: string,
+        private issuer: string,
+        private keyId: string
+    ) {}
+
+    async getTokenForUser(email: string, role?: string) {
+        const claims: Record<string, string> = {
+            sub: email
+        };
+
+        if (typeof role === 'string') {
+            claims.role = role;
+        }
+
+        const token = sign(claims, this.privateKey, {
+            issuer: this.issuer,
+            expiresIn: '5m',
+            algorithm: 'RS256',
+            keyid: this.keyId
+        });
+
+        return token;
+    }
+}

package/core/server/services/identity-tokens/IdentityTokenServiceWrapper.js

@@ -1,4 +1,4 @@
-const {IdentityTokenService} = require('@tryghost/identity-token-service');
+const {IdentityTokenService} = require('./IdentityTokenService');
 
 module.exports = class IdentityTokenServiceWrapper {
     /** @type IdentityTokenService */

package/core/server/services/invitations/accept.js

@@ -2,13 +2,16 @@ const errors = require('@tryghost/errors');
 const tpl = require('@tryghost/tpl');
 const models = require('../../models');
 const security = require('@tryghost/security');
-const messages = {inviteNotFound: 'Invite not found.',
+
+const messages = {
+    inviteNotFound: 'Invite not found.',
     inviteExpired: 'Invite is expired.',
     inviteEmailAlreadyExist: {
         message: 'Could not create an account, email is already in use.',
         context: 'Attempting to create an account with existing email address.',
         help: 'Use different email address to register your account.'
-    }};
+    }
+};
 
 async function accept(invitation) {
     const data = invitation.invitation[0];

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;

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

@@ -0,0 +1,54 @@
+const _ = require('lodash').runInContext();
+const fs = require('fs-extra');
+const path = require('path');
+
+_.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
+
+class EmailContentGenerator {
+    /**
+     *
+     * @param {Object} options
+     * @param {function} options.getSiteUrl
+     * @param {function} options.getSiteTitle
+     * @param {string} options.templatesDir - path to the directory containing email templates
+     */
+    constructor({getSiteUrl, getSiteTitle, templatesDir}) {
+        this.getSiteUrl = getSiteUrl;
+        this.getSiteTitle = getSiteTitle;
+        this.templatesDir = templatesDir;
+    }
+
+    /**
+     *
+     * @param {Object} options
+     * @param {string} options.template - HTML template name to use for generation
+     * @param {Object} [options.data] - variable data to use during HTML template compilation
+     * @returns {Promise<{html: String, text: String}>} resolves with an object containing html and text properties
+     */
+    async getContent(options) {
+        const defaults = {
+            siteUrl: this.getSiteUrl(),
+            siteTitle: this.getSiteTitle()
+        };
+
+        const data = _.defaults(defaults, options.data);
+
+        // read the proper email body template
+        const content = await fs.readFile(path.join(this.templatesDir, options.template + '.html'), 'utf8');
+
+        // insert user-specific data into the email
+        const compiled = _.template(content);
+        const htmlContent = compiled(data);
+
+        // lazyload the lib, and generate a plain-text version of the same email
+        const htmlToText = require('html-to-text');
+        const textContent = htmlToText.fromString(htmlContent);
+
+        return {
+            html: htmlContent,
+            text: textContent
+        };
+    }
+}
+
+module.exports = EmailContentGenerator;

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

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryRepository = void 0;
+const nql_1 = __importDefault(require("@tryghost/nql"));
+class InMemoryRepository {
+    store = [];
+    ids = new Map();
+    async save(entity) {
+        if (entity.deleted) {
+            this.store = this.store.filter(item => item.id !== entity.id);
+            this.ids.delete(entity.id);
+            return;
+        }
+        if (this.ids.has(entity.id)) {
+            this.store = this.store.map((item) => {
+                if (item.id === entity.id) {
+                    return entity;
+                }
+                return item;
+            });
+        }
+        else {
+            this.store.push(entity);
+            this.ids.set(entity.id, true);
+        }
+    }
+    async getById(id) {
+        return this.store.find(item => item.id === id) || null;
+    }
+    async getAll(options = {}) {
+        const filter = (0, nql_1.default)(options.filter);
+        const results = this.store.slice().filter(item => filter.queryJSON(this.toPrimitive(item)));
+        if (options.order) {
+            for (const order of options.order) {
+                results.sort((a, b) => {
+                    if (order.direction === 'asc') {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        return a[order.field] > b[order.field] ? 1 : -1;
+                    }
+                    else {
+                        return a[order.field] < b[order.field] ? 1 : -1;
+                    }
+                });
+            }
+        }
+        return results;
+    }
+    async getPage(options = { page: 1, limit: 15 }) {
+        const results = await this.getAll(options);
+        const start = (options.page - 1) * options.limit;
+        const end = start + options.limit;
+        return results.slice(start, end);
+    }
+    async getCount(options) {
+        const results = await this.getAll(options);
+        return results.length;
+    }
+}
+exports.InMemoryRepository = InMemoryRepository;

package/core/server/services/lib/InMemoryRepository.ts

@@ -0,0 +1,80 @@
+import nql from '@tryghost/nql';
+
+type Entity<T> = {
+    id: T;
+    deleted: boolean;
+}
+
+type Order<T> = {
+    field: keyof T;
+    direction: 'asc' | 'desc';
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type OrderOption<T extends Entity<any>> = Order<T>[];
+
+export abstract class InMemoryRepository<IDType, T extends Entity<IDType>> {
+    protected store: T[] = [];
+    private ids: Map<IDType, true> = new Map();
+
+    protected abstract toPrimitive(entity: T): object;
+
+    public async save(entity: T): Promise<void> {
+        if (entity.deleted) {
+            this.store = this.store.filter(item => item.id !== entity.id);
+            this.ids.delete(entity.id);
+            return;
+        }
+
+        if (this.ids.has(entity.id)) {
+            this.store = this.store.map((item) => {
+                if (item.id === entity.id) {
+                    return entity;
+                }
+                return item;
+            });
+        } else {
+            this.store.push(entity);
+            this.ids.set(entity.id, true);
+        }
+    }
+
+    public async getById(id: string): Promise<T | null> {
+        return this.store.find(item => item.id === id) || null;
+    }
+
+    public async getAll(options: { filter?: string; order?: OrderOption<T> } = {}): Promise<T[]> {
+        const filter = nql(options.filter);
+
+        const results = this.store.slice().filter(item => filter.queryJSON(this.toPrimitive(item)));
+
+        if (options.order) {
+            for (const order of options.order) {
+                results.sort((a, b) => {
+                    if (order.direction === 'asc') {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        return a[order.field] as any > (b[order.field] as any) ? 1 : -1;
+                    } else {
+                        return a[order.field] < b[order.field] ? 1 : -1;
+                    }
+                });
+            }
+        }
+
+        return results;
+    }
+
+    public async getPage(options: { filter?: string; page: number; limit: number; order?: Order<T>[] } = {page: 1, limit: 15}): Promise<T[]> {
+        const results = await this.getAll(options);
+
+        const start = (options.page - 1) * options.limit;
+        const end = start + options.limit;
+
+        return results.slice(start, end);
+    }
+
+    public async getCount(options: { filter?: string }): Promise<number> {
+        const results = await this.getAll(options);
+        return results.length;
+    }
+}