ghost 5.115.0 → 5.115.1

package/core/server/services/members/members-ssr.js

@@ -0,0 +1,333 @@
+const {parse: parseUrl} = require('url');
+const createCookies = require('cookies');
+const debug = require('@tryghost/debug')('members-ssr');
+
+const {
+    BadRequestError,
+    IncorrectUsageError
+} = require('@tryghost/errors');
+
+/**
+ * @typedef {import('http').IncomingMessage} Request
+ * @typedef {import('http').ServerResponse} Response
+ * @typedef {import('cookies').ICookies} Cookies
+ * @typedef {import('cookies').Option} CookiesOptions
+ * @typedef {import('cookies').SetOption} SetCookieOptions
+ * @typedef {string} JWT
+ */
+
+/**
+ * @typedef {object} Member
+ * @prop {string} id
+ * @prop {string} transient_id
+ * @prop {string} email
+ */
+
+const SIX_MONTHS_MS = 1000 * 60 * 60 * 24 * 184;
+
+class MembersSSR {
+    /**
+     * @typedef {object} MembersSSROptions
+     *
+     * @prop {string|string[]} cookieKeys - A secret or array of secrets used to sign cookies
+     * @prop {() => object} getMembersApi - A function which returns an instance of members-api
+     * @prop {boolean} [cookieSecure = true] - Whether the cookie should have Secure flag
+     * @prop {string} [cookieName] - The name of the members-ssr cookie
+     * @prop {number} [cookieMaxAge] - The max age in ms of the members-ssr cookie
+     * @prop {string} [cookiePath] - The Path flag for the cookie
+     * @prop {boolean} [dangerousRemovalOfSignedCookie] - Flag for removing signed cookie
+     */
+
+    /**
+     * Create an instance of MembersSSR
+     *
+     * @param {MembersSSROptions} options  - The options for the members ssr class
+     */
+    constructor(options) {
+        const {
+            cookieSecure = true,
+            cookieName = 'members-ssr',
+            cookieMaxAge = SIX_MONTHS_MS,
+            cookiePath = '/',
+            cookieKeys,
+            getMembersApi,
+            dangerousRemovalOfSignedCookie
+        } = options;
+
+        if (!getMembersApi) {
+            throw new IncorrectUsageError({message: 'Missing option getMembersApi'});
+        }
+
+        this._getMembersApi = getMembersApi;
+
+        if (!cookieKeys) {
+            throw new IncorrectUsageError({message: 'Missing option cookieKeys'});
+        }
+
+        this.sessionCookieName = cookieName;
+
+        /**
+         * @type SetCookieOptions
+         */
+        this.sessionCookieOptions = {
+            signed: true,
+            httpOnly: true,
+            sameSite: 'lax',
+            maxAge: cookieMaxAge,
+            path: cookiePath
+        };
+
+        if (dangerousRemovalOfSignedCookie === true) {
+            this.sessionCookieOptions.signed = false;
+        }
+
+        /**
+         * @type CookiesOptions
+         */
+        this.cookiesOptions = {
+            keys: Array.isArray(cookieKeys) ? cookieKeys : [cookieKeys],
+            secure: cookieSecure
+        };
+    }
+
+    /**
+     * @method _getCookies
+     *
+     * @param {Request} req
+     * @param {Response} res
+     *
+     * @returns {Cookies} An instance of the cookies object for current request/response
+     */
+    _getCookies(req, res) {
+        return createCookies(req, res, this.cookiesOptions);
+    }
+
+    /**
+     * @method _removeSessionCookie
+     *
+     * @param {Request} req
+     * @param {Response} res
+     */
+    _removeSessionCookie(req, res) {
+        const cookies = this._getCookies(req, res);
+        cookies.set(this.sessionCookieName, null, this.sessionCookieOptions);
+        // If members caching cookies are set, remove them
+        if (cookies.get('ghost-access') || cookies.get('ghost-access-hmac')) {
+            cookies.set('ghost-access', null, {...this.sessionCookieOptions, signed: false});
+            cookies.set('ghost-access-hmac', null, {...this.sessionCookieOptions, signed: false});
+        }
+    }
+
+    /**
+     * @method _setSessionCookie
+     *
+     * @param {Request} req
+     * @param {Response} res
+     * @param {string} value
+     */
+    _setSessionCookie(req, res, value) {
+        if (!value) {
+            return this._removeSessionCookie(req, res);
+        }
+        const cookies = this._getCookies(req, res);
+        cookies.set(this.sessionCookieName, value, this.sessionCookieOptions);
+    }
+
+    /**
+     * @method _getSessionCookies
+     *
+     * @param {Request} req
+     * @param {Response} res
+     *
+     * @returns {string} The cookie value
+     */
+    _getSessionCookies(req, res) {
+        const cookies = this._getCookies(req, res);
+        const value = cookies.get(this.sessionCookieName, {signed: true});
+        if (!value) {
+            throw new BadRequestError({
+                message: `Cookie ${this.sessionCookieName} not found`
+            });
+        }
+        return value;
+    }
+
+    /**
+     * @method _getMemberDataFromToken
+     *
+     * @param {JWT} token
+     *
+     * @returns {Promise<Member>} member
+     */
+    async _getMemberDataFromToken(token) {
+        const api = await this._getMembersApi();
+        return api.getMemberDataFromMagicLinkToken(token);
+    }
+
+    /**
+     * @method _getMemberIdentityData
+     *
+     * @param {string} email
+     *
+     * @returns {Promise<Member>} member
+     */
+    async _getMemberIdentityData(email) {
+        const api = await this._getMembersApi();
+        return api.getMemberIdentityData(email);
+    }
+
+    /**
+     * @method _getMemberIdentityData
+     *
+     * @param {string} transientId
+     *
+     * @returns {Promise<Member>} member
+     */
+    async _getMemberIdentityDataFromTransientId(transientId) {
+        const api = await this._getMembersApi();
+        return api.getMemberIdentityDataFromTransientId(transientId);
+    }
+
+    /**
+     * @method _getMemberIdentityToken
+     *
+     * @param {string} email
+     *
+     * @returns {Promise<JWT>} member
+     */
+    async _getMemberIdentityToken(transientId) {
+        const api = await this._getMembersApi();
+        return api.getMemberIdentityToken(transientId);
+    }
+
+    /**
+     * @method _setMemberGeolocationFromIp
+     * @param {string} email
+     * @param {string} ip
+     *
+     * @returns {Promise<Member>} member
+     */
+    async _setMemberGeolocationFromIp(email, ip) {
+        const api = await this._getMembersApi();
+        return api.setMemberGeolocationFromIp(email, ip);
+    }
+
+    /**
+     * @method exchangeTokenForSession
+     * @param {Request} req
+     * @param {Response} res
+     *
+     * @returns {Promise<Member>} The member the session was created for
+     */
+    async exchangeTokenForSession(req, res) {
+        if (!req.url) {
+            return Promise.reject(new BadRequestError({
+                message: 'Expected token param containing JWT'
+            }));
+        }
+
+        const {query} = parseUrl(req.url, true);
+        if (!query || !query.token) {
+            return Promise.reject(new BadRequestError({
+                message: 'Expected token param containing JWT'
+            }));
+        }
+
+        const token = Array.isArray(query.token) ? query.token[0] : query.token;
+        const member = await this._getMemberDataFromToken(token);
+
+        if (!member) {
+            // The member doesn't exist any longer (could be a sign in token for a member that was deleted)
+            return Promise.reject(new BadRequestError({
+                message: 'Invalid token'
+            }));
+        }
+
+        // perform and store geoip lookup for members when they log in
+        if (!member.geolocation) {
+            try {
+                await this._setMemberGeolocationFromIp(member.email, req.ip);
+            } catch (err) {
+                // no-op, we don't want to stop anything working due to
+                // geolocation lookup failing
+                debug(`Geolocation lookup failed: ${err.message}`);
+            }
+        }
+
+        this._setSessionCookie(req, res, member.transient_id);
+
+        return member;
+    }
+
+    async _cycleTransientId(memberId) {
+        const api = await this._getMembersApi();
+        return api.cycleTransientId(memberId);
+    }
+
+    /**
+     * @method deleteSession
+     * @param {Request} req
+     * @param {Response} res
+     *
+     * @returns {Promise<void>}
+     */
+    async deleteSession(req, res) {
+        if (req.body && typeof req.body === 'object' && req.body.all) {
+            // Update transient_id to invalidate all sessions
+            const member = await this.getMemberDataFromSession(req, res);
+            if (member) {
+                await this._cycleTransientId(member.id);
+            }
+        }
+        this._removeSessionCookie(req, res);
+    }
+
+    /**
+     * @method getMemberDataFromSession
+     *
+     * @param {Request} req
+     * @param {Response} res
+     *
+     * @returns {Promise<Member>}
+     */
+    async getMemberDataFromSession(req, res) {
+        const transientId = this._getSessionCookies(req, res);
+        const member = await this._getMemberIdentityDataFromTransientId(transientId);
+        return member;
+    }
+
+    /**
+     * @method getIdentityTokenForMemberFromSession
+     *
+     * @param {Request} req
+     * @param {Response} res
+     *
+     * @returns {Promise<JWT>} identity token
+     */
+    async getIdentityTokenForMemberFromSession(req, res) {
+        const transientId = this._getSessionCookies(req, res);
+        const token = await this._getMemberIdentityToken(transientId);
+        if (!token) {
+            await this.deleteSession(req, res);
+            throw new BadRequestError({
+                message: 'Invalid session, could not get identity token'
+            });
+        }
+        return token;
+    }
+}
+
+/**
+ * Factory function for creating instance of MembersSSR
+ *
+ * @param {MembersSSROptions} options
+ * @returns {MembersSSR}
+ */
+module.exports = function create(options) {
+    if (!options) {
+        throw new IncorrectUsageError({
+            message: 'Must pass options'
+        });
+    }
+    return new MembersSSR(options);
+};

package/core/server/services/members/service.js

@@ -1,10 +1,10 @@
 const _ = require('lodash');
 const errors = require('@tryghost/errors');
 const tpl = require('@tryghost/tpl');
-const MembersSSR = require('@tryghost/members-ssr');
+const MembersSSR = require('./members-ssr');
 const db = require('../../data/db');
 const MembersConfigProvider = require('./MembersConfigProvider');
-const makeMembersCSVImporter = require('@tryghost/members-importer');
+const makeMembersCSVImporter = require('./importer');
 const MembersStats = require('./stats/MembersStats');
 const memberJobs = require('./jobs');
 const logging = require('@tryghost/logging');

package/core/server/services/posts/stats/PostStats.js

@@ -20,6 +20,19 @@ class PostStats {
         return result?.[0]?.published_at ? new Date(result?.[0]?.published_at) : null;
     }
 
+    /**
+     * Returns the first published post date
+     */
+    async getFirstPublishedPostDate() {
+        const result = await this.#db.knex.select('published_at')
+            .from('posts')
+            .whereIn('status', ['sent', 'published'])
+            .orderBy('published_at', 'asc')
+            .limit(1);
+
+        return result?.[0]?.published_at ? new Date(result?.[0]?.published_at) : null;
+    }
+
     /**
      * Fetches count of all published posts
      */

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

@@ -0,0 +1,47 @@
+const path = require('path');
+const tpl = require('@tryghost/tpl');
+const format = require('date-fns/format');
+const {IncorrectUsageError} = require('@tryghost/errors');
+
+const messages = {
+    incorrectPathsParameter: 'Attempted to setup settings path manager without paths values.'
+};
+
+class SettingsPathManager {
+    /**
+     *
+     * @param {Object} options
+     * @param {String[]} options.paths - file location paths ordered in priority by where to locate them first
+     * @param {String} options.type setting file type, e.g: 'routes' or 'redirects'
+     * @param {String[]} [options.extensions] the supported file extensions with 'yaml' and 'json' defaults. Note 'yml' extension is ignored on purpose
+    */
+    constructor({type, paths, extensions = ['yaml', 'json']}) {
+        if (!paths || !paths.length) {
+            throw new IncorrectUsageError({
+                message: tpl(messages.incorrectPathsParameter)
+            });
+        }
+
+        this.type = type;
+        this.filename = type;
+
+        this.paths = paths;
+        this.defaultPath = paths[0];
+
+        this.extensions = extensions;
+        this.defaultExtension = extensions[0];
+    }
+
+    getDefaultFilePath() {
+        const settingsFolder = this.defaultPath;
+        return path.join(settingsFolder, `${this.filename}.${this.defaultExtension}`);
+    }
+
+    getBackupFilePath() {
+        const settingsFolder = this.defaultPath;
+        const dateStamp = format(new Date(), 'yyyy-MM-dd-HH-mm-ss');
+        return path.join(settingsFolder, `${this.filename}-${dateStamp}.${this.defaultExtension}`);
+    }
+}
+
+module.exports = SettingsPathManager;

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

@@ -1,6 +1,5 @@
 const config = require('../../../shared/config');
 const parseYaml = require('./yaml-parser');
-const SettingsPathManager = require('@tryghost/settings-path-manager');
 
 let settingsLoader;
 let routeSettings;
@@ -10,6 +9,7 @@ module.exports = {
         const RouteSettings = require('./RouteSettings');
         const SettingsLoader = require('./SettingsLoader');
         const DefaultSettingsManager = require('./DefaultSettingsManager');
+        const SettingsPathManager = require('./SettingsPathManager');
 
         const settingsPathManager = new SettingsPathManager({type: 'routes', paths: [config.getContentPath('settings')]});
         settingsLoader = new SettingsLoader({parseYaml, settingFilePath: settingsPathManager.getDefaultFilePath()});

package/core/server/services/stripe/README.md

@@ -0,0 +1,63 @@
+# Stripe Service
+This package contains code for Ghost's Stripe integration. It interacts with Stripe's API and handles webhooks.
+
+The main export of this package is the `StripeService` class. It includes a wrapper around the Stripe API and webhook handling logic. It is instantiated in Ghost's `core/server/services/stripe` service.
+
+## Stripe API
+The `StripeAPI` class is a wrapper around the Stripe API. It is used by the `StripeService` class to interact with Stripe's API.
+
+## Stripe Webhooks
+Ghost listens for Stripe webhooks to know when a customer has subscribed to a plan, when a subscription has been cancelled, when a payment has failed, etc.
+
+Things to keep in mind when working with Stripe webhooks:
+- Webhooks can arrive out of order. `checkout.session.completed` webhooks may arrive before or after `customer.subscription.created` webhooks.
+- Webhooks can be received and processed in parallel, so you should not rely on the order of the webhooks to determine the order of operations.
+- Operations in Stripe almost always produce multiple events, increasing the likelihood of race conditions.
+
+See Stripe's [Webhooks Guide](https://docs.stripe.com/webhooks) for more information.
+
+### Webhook Manager
+This class is responsible for registering the webhook endpoints with Stripe, so Stripe knows where to send the webhooks.
+
+### Webhook Controller
+This class is responsible for handling the webhook events. It accepts the webhook event payload and delegates it to the appropriate handler based on the event type.
+
+### Events
+The Webhook Controller listens for the following events:
+- `customer.subscription.deleted`
+- `customer.subscription.updated`
+- `customer.subscription.created`
+- `invoice.payment_succeeded`
+- `checkout.session.completed`
+
+
+## Stripe Flows
+
+### Checkout Session Flow: New Subscription
+```mermaid
+sequenceDiagram
+    actor Member as Member
+    participant Portal
+    participant Ghost
+    participant Stripe
+
+    Member->>Portal: Signs up for a paid plan
+    Portal->>Ghost: Create checkout session
+    Ghost->>Stripe: Create checkout session
+    Stripe-->>Ghost: Return session ID
+    Ghost-->>Portal: Return session ID
+    Portal->>Stripe: Redirect to checkout page
+    Note over Portal: Member enters payment details in Stripe's secure portal
+    Stripe-->>Portal: Redirect to success URL
+    
+    par Webhook Events
+        Stripe->>Ghost: customer.subscription.created
+        Ghost->>Ghost: Upsert member and subscription
+        Stripe->>Ghost: checkout.session.completed
+        Ghost->>Ghost: Upsert member and subscription
+        Stripe->>Ghost: customer.subscription.updated
+        Ghost->>Ghost: Upsert member and subscription
+        Stripe->>Ghost: invoice.payment_succeeded
+        Ghost->>Ghost: Record payment
+    end
+```