ghost 6.44.0 → 6.44.1

package/core/frontend/services/sitemap/handler.js

@@ -13,13 +13,7 @@ module.exports = function handler(siteApp) {
         next();
     };
 
-    siteApp.get('/sitemap.xml', async function sitemapXML(req, res, next) {
-        try {
-            await manager.ensurePopulatedFromDatabase();
-        } catch (err) {
-            return next(err);
-        }
-
+    siteApp.get('/sitemap.xml', function sitemapXML(req, res) {
         res.set({
             'Cache-Control': 'public, max-age=' + config.get('caching:sitemap:maxAge'),
             'Content-Type': 'text/xml'
@@ -28,17 +22,11 @@ module.exports = function handler(siteApp) {
         res.send(manager.getIndexXml());
     });
 
-    siteApp.get('/sitemap-:resource.xml', verifyResourceType, async function sitemapResourceXML(req, res, next) {
+    siteApp.get('/sitemap-:resource.xml', verifyResourceType, function sitemapResourceXML(req, res) {
         const type = req.params.resource.replace(/-\d+$/, '');
         const pageParam = (req.params.resource.match(/-(\d+)$/) || [null, null])[1];
         const page = pageParam ? parseInt(pageParam, 10) : 1;
 
-        try {
-            await manager.ensurePopulatedFromDatabase();
-        } catch (err) {
-            return next(err);
-        }
-
         const content = manager.getSiteMapXml(type, page);
         // Prevent x-1.xml as it is a duplicate of x.xml and empty sitemaps
         // (except for the first page so that at least one sitemap exists per type)

package/core/frontend/services/sitemap/site-map-manager.js

@@ -1,5 +1,4 @@
 const DomainEvents = require('@tryghost/domain-events');
-const config = require('../../../shared/config');
 const {URLResourceUpdatedEvent} = require('../../../shared/events');
 const IndexMapGenerator = require('./site-map-index-generator');
 const PagesMapGenerator = require('./page-map-generator');
@@ -22,20 +21,6 @@ class SiteMapManager {
         this.tags = options.tags || this.createTagsGenerator(options);
         this.index = options.index || this.createIndexGenerator(options);
 
-        // The lazy URL service does not fire url.added / url.removed /
-        // URLResourceUpdatedEvent. When that mode is active the sitemap
-        // populates itself from the database on first request instead.
-        this._lazyRouting = options.lazyRouting === undefined
-            ? config.get('lazyRouting')
-            : options.lazyRouting;
-        this._populated = false;
-        this._populating = null;
-        // Each routers.reset bumps this generation. An in-flight populate
-        // captures the generation it started in; if that generation is no
-        // longer current when the populate settles, its result is discarded
-        // so we don't mark a stale (potentially mid-reset) lookup as ready.
-        this._populationGeneration = 0;
-
         events.on('router.created', (router) => {
             if (router.name === 'StaticRoutesRouter') {
                 this.pages.addUrl(router.getRoute({absolute: true}), {id: router.identifier, staticRoute: true});
@@ -46,31 +31,23 @@ class SiteMapManager {
             }
         });
 
-        if (!this._lazyRouting) {
-            DomainEvents.subscribe(URLResourceUpdatedEvent, (event) => {
-                this[event.data.resourceType].updateURL(event.data);
-            });
+        DomainEvents.subscribe(URLResourceUpdatedEvent, (event) => {
+            this[event.data.resourceType].updateURL(event.data);
+        });
 
-            events.on('url.added', (obj) => {
-                this[obj.resource.config.type].addUrl(obj.url.absolute, obj.resource.data);
-            });
+        events.on('url.added', (obj) => {
+            this[obj.resource.config.type].addUrl(obj.url.absolute, obj.resource.data);
+        });
 
-            events.on('url.removed', (obj) => {
-                this[obj.resource.config.type].removeUrl(obj.url.absolute, obj.resource.data);
-            });
-        }
+        events.on('url.removed', (obj) => {
+            this[obj.resource.config.type].removeUrl(obj.url.absolute, obj.resource.data);
+        });
 
         events.on('routers.reset', () => {
             this.pages && this.pages.reset();
             this.posts && this.posts.reset();
             this.users && this.users.reset();
             this.tags && this.tags.reset();
-            // Force the next sitemap request to repopulate from the DB.
-            // Bumping the generation invalidates any populate currently in
-            // flight (its `.then` will see a stale generation and bail).
-            this._populated = false;
-            this._populating = null;
-            this._populationGeneration += 1;
         });
     }
 
@@ -109,188 +86,6 @@ class SiteMapManager {
     getSiteMapXml(type, page) {
         return this[type].getXml(page);
     }
-
-    /**
-     * Populate the sitemap from the database. Used when the lazy URL service
-     * is active and the URL-added/-removed events are not firing. Idempotent;
-     * a second call is a no-op while the first is in flight or has finished.
-     */
-    async ensurePopulatedFromDatabase() {
-        if (!this._lazyRouting || this._populated) {
-            return;
-        }
-        if (this._populating) {
-            return this._populating;
-        }
-        const generation = this._populationGeneration;
-        const populating = this._populateFromDatabase().then(
-            () => {
-                // If a routers.reset happened while we were running, the
-                // generators have been wiped. Don't flip _populated; let the
-                // next request kick off a fresh populate.
-                if (this._populationGeneration === generation) {
-                    this._populated = true;
-                }
-                // Only clear our own handle. routers.reset already nulled
-                // _populating and a successor populate may have replaced it
-                // — clobbering would orphan the successor.
-                if (this._populating === populating) {
-                    this._populating = null;
-                }
-            },
-            (err) => {
-                if (this._populating === populating) {
-                    this._populating = null;
-                }
-                throw err;
-            }
-        );
-        this._populating = populating;
-        return this._populating;
-    }
-
-    async _populateFromDatabase() {
-        const models = require('../../../server/models');
-        const urlService = require('../../../server/services/url');
-        const facade = urlService.facade;
-
-        await Promise.all([
-            this._loadType('posts', this.posts, facade, models),
-            this._loadType('pages', this.pages, facade, models),
-            this._loadType('tags', this.tags, facade, models),
-            this._loadType('authors', this.users, facade, models)
-        ]);
-    }
-
-    async _loadType(type, generator, facade, models) {
-        const fetchOptions = TYPE_FETCH_OPTIONS[type];
-        if (!fetchOptions) {
-            return;
-        }
-        // Use the same raw-knex path as the eager URL service's resource
-        // fetcher (services/url/resources.js → raw_knex.fetchAll). The
-        // previous implementation went through Bookshelf's findPage and
-        // toPlain per row, which is minutes-not-seconds for 50k posts —
-        // slow enough that edge proxies 503 on the first sitemap request.
-        const objects = await models.Base.Model.raw_knex.fetchAll(fetchOptions);
-        for (const datum of objects) {
-            const url = facade.getUrlForResource({...datum, type}, {absolute: true});
-            if (url && !url.match(/\/404\//)) {
-                generator.addUrl(url, datum);
-            }
-        }
-    }
 }
 
-// Mirrors the eager URL service's resource configs (services/url/config.js)
-// so the lazy sitemap renders the same URL set as the eager service would.
-// When the eager service is removed this becomes the only copy — kept
-// inline (rather than imported from services/url) so the eager removal is
-// a clean delete.
-//
-// The `exclude` lists trim heavy columns (mobiledoc, lexical, html,
-// plaintext, codeinjection, og/twitter card fields, …) before they ever
-// reach memory. Without them, fetchAll loads the full body of every post
-// — multiple GB on a 50k-post site.
-//
-// `withRelated: ['tags', 'authors']` for posts is what surfaces
-// `primary_tag` / `primary_author` on the result: Post.toJSON's computed
-// `primary_tag` field (models/post.js) and the authors-relation
-// serialize mixin both run as part of raw_knex.fetchAll's per-row
-// toJSON pass, gated only on the relation being loaded.
-const TYPE_FETCH_OPTIONS = {
-    posts: {
-        modelName: 'Post',
-        filter: 'status:published+type:post',
-        exclude: [
-            'title',
-            'mobiledoc',
-            'lexical',
-            'html',
-            'plaintext',
-            'status',
-            'codeinjection_head',
-            'codeinjection_foot',
-            'meta_title',
-            'meta_description',
-            'custom_excerpt',
-            'og_image',
-            'og_title',
-            'og_description',
-            'twitter_image',
-            'twitter_title',
-            'twitter_description',
-            'custom_template',
-            'locale',
-            'newsletter_id',
-            'show_title_and_feature_image',
-            'email_recipient_filter',
-            'comment_id',
-            'tiers'
-        ],
-        withRelated: ['tags', 'authors'],
-        withRelatedFields: {
-            tags: ['tags.id', 'tags.slug'],
-            authors: ['users.id', 'users.slug']
-        }
-    },
-    pages: {
-        modelName: 'Post',
-        filter: 'status:published+type:page',
-        exclude: [
-            'title',
-            'mobiledoc',
-            'lexical',
-            'html',
-            'plaintext',
-            'codeinjection_head',
-            'codeinjection_foot',
-            'meta_title',
-            'meta_description',
-            'custom_excerpt',
-            'og_image',
-            'og_title',
-            'og_description',
-            'twitter_image',
-            'twitter_title',
-            'twitter_description',
-            'custom_template',
-            'locale',
-            'tags',
-            'authors',
-            'primary_tag',
-            'primary_author',
-            'newsletter_id',
-            'show_title_and_feature_image',
-            'email_recipient_filter',
-            'comment_id',
-            'tiers'
-        ]
-    },
-    tags: {
-        modelName: 'Tag',
-        filter: 'visibility:public',
-        exclude: ['description', 'meta_title', 'meta_description', 'parent_id'],
-        shouldHavePosts: {joinTo: 'tag_id', joinTable: 'posts_tags'}
-    },
-    authors: {
-        modelName: 'User',
-        filter: 'visibility:public',
-        exclude: [
-            'bio',
-            'website',
-            'location',
-            'facebook',
-            'twitter',
-            'locale',
-            'accessibility',
-            'meta_title',
-            'meta_description',
-            'tour',
-            'last_seen'
-        ],
-        shouldHavePosts: {joinTo: 'author_id', joinTable: 'posts_authors'}
-    }
-};
-
 module.exports = SiteMapManager;

package/core/server/api/endpoints/comment-replies.js

@@ -53,8 +53,7 @@ const controller = {
         },
         permissions: true,
         query(frame) {
-            frame.options.isAdmin = true;
-            return commentsService.controller.read(frame);
+            return commentsService.controller.adminRead(frame);
         }
     }
 };

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

@@ -9,6 +9,7 @@ const membersService = require('../../services/members');
 const settingsCache = require('../../../shared/settings-cache');
 const tpl = require('@tryghost/tpl');
 const _ = require('lodash');
+const {slugify} = require('@tryghost/string');
 
 const messages = {
     memberNotFound: 'Member not found.',
@@ -378,7 +379,9 @@ const controller = {
                 type: 'csv',
                 value() {
                     const datetime = (new Date()).toJSON().substring(0, 10);
-                    return `members.${datetime}.csv`;
+                    const title = settingsCache.get('title');
+                    const titlePrefix = title ? `${slugify(title)}.` : '';
+                    return `${titlePrefix}ghost.members.${datetime}.csv`;
                 }
             },
             contentType: 'text/csv',

package/core/server/api/endpoints/search-index-public.js

@@ -1,7 +1,18 @@
 const models = require('../../models');
+const config = require('../../../shared/config');
 const getPostServiceInstance = require('../../services/posts/posts-service-instance');
 const postsService = getPostServiceInstance();
 
+const urlRelationsWhenLazyRouting = () => {
+    if (config.get('lazyRouting')) {
+        return {
+            withRelated: ['tags', 'authors']
+        };
+    }
+
+    return {};
+};
+
 /** @type {import('@tryghost/api-framework').Controller} */
 const controller = {
     docName: 'search_index',
@@ -16,7 +27,7 @@ const controller = {
                 limit: '10000',
                 order: 'updated_at DESC',
                 columns: ['id', 'slug', 'title', 'excerpt', 'url', 'updated_at', 'visibility'],
-                withRelated: ['tags', 'authors']
+                ...urlRelationsWhenLazyRouting()
             };
 
             return postsService.browsePosts(options);

package/core/server/api/endpoints/search-index.js

@@ -1,7 +1,18 @@
 const models = require('../../models');
+const config = require('../../../shared/config');
 const getPostServiceInstance = require('../../services/posts/posts-service-instance');
 const postsService = getPostServiceInstance();
 
+const urlRelationsWhenLazyRouting = () => {
+    if (config.get('lazyRouting')) {
+        return {
+            withRelated: ['tags', 'authors']
+        };
+    }
+
+    return {};
+};
+
 /** @type {import('@tryghost/api-framework').Controller} */
 const controller = {
     docName: 'search_index',
@@ -19,7 +30,7 @@ const controller = {
                 limit: '10000',
                 order: 'updated_at DESC',
                 columns: ['id', 'uuid', 'url', 'title', 'slug', 'status', 'published_at', 'visibility'],
-                withRelated: ['tags', 'authors']
+                ...urlRelationsWhenLazyRouting()
             };
 
             return postsService.browsePosts(options);
@@ -39,7 +50,7 @@ const controller = {
                 limit: '10000',
                 order: 'updated_at DESC',
                 columns: ['id', 'uuid', 'url', 'title', 'slug', 'status', 'published_at', 'visibility'],
-                withRelated: ['tags', 'authors']
+                ...urlRelationsWhenLazyRouting()
             };
 
             return postsService.browsePosts(options);

package/core/server/lib/bootstrap-socket.js

@@ -1,87 +1,82 @@
-const logging = require('@tryghost/logging');
-
-module.exports.connectAndSend = (socketAddress, message) => {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectAndSend = void 0;
+const node_net_1 = __importDefault(require("node:net"));
+const logging_1 = __importDefault(require("@tryghost/logging"));
+const getErrorCode = (err) => (err && typeof err === 'object' && 'code' in err && typeof err.code === 'string'
+    ? err.code
+    : undefined);
+const isValidPort = (port) => (typeof port === 'number' &&
+    Number.isInteger(port) &&
+    port >= 1 &&
+    port <= 65535);
+const hasSocketAddress = (socketAddress) => (typeof socketAddress?.host === 'string' && Boolean(socketAddress.host) &&
+    isValidPort(socketAddress.port));
+const connectAndSend = (socketAddress, message) => {
     // Very basic guard against bad calls
-    if (!socketAddress || !socketAddress.host || !socketAddress.port || !logging || !logging.info || !logging.warn || !message) {
+    if (!hasSocketAddress(socketAddress) || !logging_1.default || !logging_1.default.info || !logging_1.default.warn || message === undefined) {
         return Promise.resolve();
     }
-
-    const net = require('net');
-    const client = new net.Socket();
-
+    const client = new node_net_1.default.Socket();
     return new Promise((resolve) => {
-        const connect = (options = {}) => {
+        const connect = (options) => {
             let wasResolved = false;
-
             const waitTimeout = setTimeout(() => {
-                logging.info('Bootstrap socket timed out.');
-
+                logging_1.default.info('Bootstrap socket timed out.');
                 if (!client.destroyed) {
                     client.destroy();
                 }
-
                 if (wasResolved) {
                     return;
                 }
-
                 wasResolved = true;
                 resolve();
             }, 1000 * 5);
-
             client.connect(socketAddress.port, socketAddress.host, () => {
                 if (waitTimeout) {
                     clearTimeout(waitTimeout);
                 }
-
                 client.write(JSON.stringify(message));
-
                 if (wasResolved) {
                     return;
                 }
-
                 wasResolved = true;
                 resolve();
             });
-
             client.on('close', () => {
-                logging.info('Bootstrap client was closed.');
-
+                logging_1.default.info('Bootstrap client was closed.');
                 if (waitTimeout) {
                     clearTimeout(waitTimeout);
                 }
             });
-
             client.on('error', (err) => {
-                logging.warn(`Can't connect to the bootstrap socket (${socketAddress.host} ${socketAddress.port}) ${err.code}.`);
-
+                logging_1.default.warn(`Can't connect to the bootstrap socket (${socketAddress.host} ${socketAddress.port}) ${getErrorCode(err)}.`);
                 client.removeAllListeners();
-
                 if (waitTimeout) {
                     clearTimeout(waitTimeout);
                 }
-
                 if (options.tries < 3) {
-                    logging.warn(`Tries: ${options.tries}`);
-
+                    logging_1.default.warn(`Tries: ${options.tries}`);
                     // retry
-                    logging.warn('Retrying...');
-
-                    options.tries = options.tries + 1;
+                    logging_1.default.warn('Retrying...');
                     const retryTimeout = setTimeout(() => {
                         clearTimeout(retryTimeout);
-                        connect(options);
+                        connect({ tries: options.tries + 1 });
                     }, 150);
-                } else {
+                }
+                else {
                     if (wasResolved) {
                         return;
                     }
-
                     wasResolved = true;
                     resolve();
                 }
             });
         };
-
-        connect({tries: 0});
+        connect({ tries: 0 });
     });
 };
+exports.connectAndSend = connectAndSend;

package/core/server/lib/bootstrap-socket.ts

@@ -0,0 +1,114 @@
+import net from 'node:net';
+import logging from '@tryghost/logging';
+import type {JsonValue} from 'type-fest';
+
+type SocketAddress = Readonly<{
+    host: string;
+    port: number;
+}>;
+
+type ConnectOptions = Readonly<{
+    tries: number;
+}>;
+
+const getErrorCode = (err: unknown): undefined | string => (
+    err && typeof err === 'object' && 'code' in err && typeof err.code === 'string'
+        ? err.code
+        : undefined
+);
+
+const isValidPort = (port: unknown): port is number => (
+    typeof port === 'number' &&
+    Number.isInteger(port) &&
+    port >= 1 &&
+    port <= 65535
+);
+
+const hasSocketAddress = (socketAddress?: Partial<SocketAddress>): socketAddress is SocketAddress => (
+    typeof socketAddress?.host === 'string' && Boolean(socketAddress.host) &&
+    isValidPort(socketAddress.port)
+);
+
+export const connectAndSend = (socketAddress?: Partial<SocketAddress>, message?: JsonValue): Promise<void> => {
+    // Very basic guard against bad calls
+    if (!hasSocketAddress(socketAddress) || !logging || !logging.info || !logging.warn || message === undefined) {
+        return Promise.resolve();
+    }
+
+    const client = new net.Socket();
+
+    return new Promise((resolve: () => void) => {
+        const connect = (options: ConnectOptions) => {
+            let wasResolved = false;
+
+            const waitTimeout = setTimeout(() => {
+                logging.info('Bootstrap socket timed out.');
+
+                if (!client.destroyed) {
+                    client.destroy();
+                }
+
+                if (wasResolved) {
+                    return;
+                }
+
+                wasResolved = true;
+                resolve();
+            }, 1000 * 5);
+
+            client.connect(socketAddress.port, socketAddress.host, () => {
+                if (waitTimeout) {
+                    clearTimeout(waitTimeout);
+                }
+
+                client.write(JSON.stringify(message));
+
+                if (wasResolved) {
+                    return;
+                }
+
+                wasResolved = true;
+                resolve();
+            });
+
+            client.on('close', () => {
+                logging.info('Bootstrap client was closed.');
+
+                if (waitTimeout) {
+                    clearTimeout(waitTimeout);
+                }
+            });
+
+            client.on('error', (err: Error) => {
+                logging.warn(`Can't connect to the bootstrap socket (${socketAddress.host} ${socketAddress.port}) ${getErrorCode(err)}.`);
+
+                client.removeAllListeners();
+
+                if (waitTimeout) {
+                    clearTimeout(waitTimeout);
+                }
+
+                if (options.tries < 3) {
+                    logging.warn(`Tries: ${options.tries}`);
+
+                    // retry
+                    logging.warn('Retrying...');
+
+                    const retryTimeout = setTimeout(() => {
+                        clearTimeout(retryTimeout);
+                        connect({tries: options.tries + 1});
+                    }, 150);
+                } else {
+                    if (wasResolved) {
+                        return;
+                    }
+
+                    wasResolved = true;
+                    resolve();
+                }
+            });
+        };
+
+        connect({tries: 0});
+    });
+};

package/core/server/lib/common/to-plain.js

@@ -1,21 +1,9 @@
-/**
- * Normalise a Bookshelf model or plain object to its JSON representation.
- *
- * Bookshelf models expose their data via `.toJSON()` and store it on a private
- * `attributes` map; spreading them with `{...model}` skips the prototype-defined
- * getters (including `id`) and so silently loses the data. This helper lets
- * callers accept either shape uniformly:
- *
- *   const data = toPlain(post);
- *   urlService.facade.getUrlForResource({...data, type: 'posts'}, ...)
- *
- * @template T
- * @param {T | {toJSON(): T}} modelOrObj
- * @returns {T}
- */
-module.exports = function toPlain(modelOrObj) {
-    if (modelOrObj && typeof modelOrObj.toJSON === 'function') {
-        return modelOrObj.toJSON();
-    }
-    return modelOrObj;
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPlain = void 0;
+const isJsonSerializable = (modelOrObj) => !!(modelOrObj
+    && typeof modelOrObj === 'object'
+    && 'toJSON' in modelOrObj
+    && typeof modelOrObj.toJSON === 'function');
+const toPlain = (modelOrObj) => (isJsonSerializable(modelOrObj) ? modelOrObj.toJSON() : modelOrObj);
+exports.toPlain = toPlain;

package/core/server/lib/common/to-plain.ts

@@ -0,0 +1,25 @@
+/**
+ * Normalise a Bookshelf model or plain object to its JSON representation.
+ *
+ * Bookshelf models expose their data via `.toJSON()` and store it on a private
+ * `attributes` map; spreading them with `{...model}` skips the prototype-defined
+ * getters (including `id`) and so silently loses the data. This helper lets
+ * callers accept either shape uniformly:
+ *
+ *   const data = toPlain(post);
+ *   urlService.facade.getUrlForResource({...data, type: 'posts'}, ...)
+ */
+type JsonSerializable<T> = {
+    toJSON(): T;
+};
+
+const isJsonSerializable = <T>(modelOrObj: T | JsonSerializable<T>): modelOrObj is JsonSerializable<T> => !!(
+    modelOrObj
+    && typeof modelOrObj === 'object'
+    && 'toJSON' in modelOrObj
+    && typeof modelOrObj.toJSON === 'function'
+);
+
+export const toPlain = <T>(modelOrObj: T | JsonSerializable<T>): T => (
+    isJsonSerializable(modelOrObj) ? modelOrObj.toJSON() : modelOrObj
+);