ghost 6.54.0 → 6.55.0

package/core/server/services/route-settings/activation-bridge.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expandRouteSettings = expandRouteSettings;
+exports.buildRouterSettings = buildRouterSettings;
 const lodash_1 = __importDefault(require("lodash"));
 const errors_1 = __importDefault(require("@tryghost/errors"));
 const config_1 = require("../../../frontend/services/routing/config");
@@ -87,78 +87,88 @@ function expandRouteData(routeData) {
 function convertSlugsToColons(value) {
     return value.replace(/{(\w+)}/g, ':$1');
 }
-function expandRoute(route) {
-    const expanded = {};
-    expanded.templates = route.templates || [];
-    if (route.data !== undefined) {
-        expanded.data = expandRouteData(route.data);
-    }
+function buildRouterRoute(route) {
+    const data = route.data !== undefined ? expandRouteData(route.data) : undefined;
+    // Build per branch: RouterRoute is a discriminated union, so each member is
+    // constructed as its concrete type. `route` is narrowed by the check.
     if (route.type === 'channel') {
-        const channel = route;
-        expanded.controller = 'channel';
-        if (channel.filter !== undefined) {
-            expanded.filter = channel.filter;
+        const result = {
+            path: route.path,
+            type: 'channel',
+            templates: route.templates || []
+        };
+        if (data !== undefined) {
+            result.data = data;
         }
-        if (channel.order !== undefined) {
-            expanded.order = channel.order;
+        if (route.filter !== undefined) {
+            result.filter = route.filter;
         }
-        if (channel.limit !== undefined) {
-            expanded.limit = channel.limit;
+        if (route.order !== undefined) {
+            result.order = route.order;
         }
-        if (channel.rss !== undefined) {
-            expanded.rss = channel.rss;
+        if (route.limit !== undefined) {
+            result.limit = route.limit;
         }
-    }
-    else {
-        const template = route;
-        if (template.contentType !== undefined) {
-            expanded.content_type = template.contentType;
+        if (route.rss !== undefined) {
+            result.rss = route.rss;
         }
+        return result;
+    }
+    const result = {
+        path: route.path,
+        type: 'template',
+        templates: route.templates || []
+    };
+    if (data !== undefined) {
+        result.data = data;
     }
-    return expanded;
+    if (route.contentType !== undefined) {
+        result.contentType = route.contentType;
+    }
+    return result;
 }
-function expandCollection(collection) {
-    const expanded = {};
-    expanded.permalink = convertSlugsToColons(collection.permalink);
-    expanded.templates = collection.templates || [];
+function buildRouterCollection(collection) {
+    const result = {
+        path: collection.path,
+        permalink: convertSlugsToColons(collection.permalink),
+        templates: collection.templates || []
+    };
     if (collection.data !== undefined) {
-        expanded.data = expandRouteData(collection.data);
+        result.data = expandRouteData(collection.data);
     }
     if (collection.filter !== undefined) {
-        expanded.filter = collection.filter;
+        result.filter = collection.filter;
     }
     if (collection.order !== undefined) {
-        expanded.order = collection.order;
+        result.order = collection.order;
     }
     if (collection.limit !== undefined) {
-        expanded.limit = collection.limit;
+        result.limit = collection.limit;
     }
     if (collection.rss !== undefined) {
-        expanded.rss = collection.rss;
+        result.rss = collection.rss;
     }
-    return expanded;
+    return result;
 }
 /**
- * Converts a RouteSettings domain model into the legacy expanded format
- * that routerManager.start() expects.
+ * Converts a RouteSettings domain model into the array shape that
+ * RouterManager.start() iterates. Each route/collection carries its own `path`,
+ * and taxonomies become `{key, permalink}` entries, so the routing layer no
+ * longer reads paths from map keys.
  *
- * This is a temporary adapter — it gets removed once RouterManager is
- * refactored to consume the domain model directly (HKG-1895/HKG-1898).
+ * Temporary adapter: removed in HKG-1898 once the routers consume the domain
+ * model directly.
  */
-function expandRouteSettings(settings) {
-    const routes = {};
-    for (const route of settings.routes) {
-        routes[route.path] = expandRoute(route);
-    }
-    const collections = {};
-    for (const collection of settings.collections) {
-        collections[collection.path] = expandCollection(collection);
-    }
-    const taxonomies = {};
+function buildRouterSettings(settings) {
+    const taxonomies = [];
     for (const [key, value] of Object.entries(settings.taxonomies)) {
         if (value) {
-            taxonomies[key] = convertSlugsToColons(value);
+            taxonomies.push({ key, permalink: convertSlugsToColons(value) });
         }
     }
-    return { routes, collections, taxonomies };
+    return {
+        routes: settings.routes.map(buildRouterRoute),
+        collections: settings.collections.map(buildRouterCollection),
+        taxonomies
+    };
 }

package/core/server/services/route-settings/activation-bridge.ts

@@ -121,90 +121,130 @@ function convertSlugsToColons(value: string): string {
     return value.replace(/{(\w+)}/g, ':$1');
 }
 
-function expandRoute(route: Route): Record<string, any> {
-    const expanded: Record<string, any> = {};
+/**
+ * Router-facing shapes. RouterManager consumes the domain model after the two
+ * conversions the bridge still applies: `data` expanded to `{query, router}`,
+ * and collection/taxonomy permalinks rewritten to `:slug`.
+ *
+ * Routes and collections are written as their domain counterpart with just
+ * `data` overridden to the expanded shape — `Omit<…, 'data'> & {data?}` rather
+ * than `extends`, because the override changes `data`'s type (interface
+ * extension can only add fields, not retype them). That keeps the delta from
+ * the domain model explicit: `data` is the only structural difference. When the
+ * bridge is removed (HKG-1898) the override falls away and these collapse back
+ * to `Route` / `CollectionConfig`.
+ */
+type RouterChannelRoute = Omit<ChannelRoute, 'data'> & {data?: ExpandedData};
+type RouterTemplateRoute = Omit<TemplateRoute, 'data'> & {data?: ExpandedData};
+type RouterRoute = RouterChannelRoute | RouterTemplateRoute;
+
+type RouterCollection = Omit<CollectionConfig, 'data'> & {data?: ExpandedData};
+
+// Taxonomies and RouteSettings have no direct domain counterpart to derive from:
+// the domain stores taxonomies as a `{tag, author}` map, which the bridge
+// flattens into these `{key, permalink}` entries, and RouterSettings drops
+// `yamlSource` and swaps all three array element types (routes, collections,
+// taxonomies) — so they stay standalone.
+interface RouterTaxonomy {
+    key: string;
+    permalink: string;
+}
 
-    expanded.templates = route.templates || [];
+export interface RouterSettings {
+    routes: RouterRoute[];
+    collections: RouterCollection[];
+    taxonomies: RouterTaxonomy[];
+}
 
-    if (route.data !== undefined) {
-        expanded.data = expandRouteData(route.data);
-    }
+function buildRouterRoute(route: Route): RouterRoute {
+    const data = route.data !== undefined ? expandRouteData(route.data) : undefined;
 
+    // Build per branch: RouterRoute is a discriminated union, so each member is
+    // constructed as its concrete type. `route` is narrowed by the check.
     if (route.type === 'channel') {
-        const channel = route as ChannelRoute;
-        expanded.controller = 'channel';
-        if (channel.filter !== undefined) {
-            expanded.filter = channel.filter;
+        const result: RouterChannelRoute = {
+            path: route.path,
+            type: 'channel',
+            templates: route.templates || []
+        };
+        if (data !== undefined) {
+            result.data = data;
         }
-        if (channel.order !== undefined) {
-            expanded.order = channel.order;
+        if (route.filter !== undefined) {
+            result.filter = route.filter;
         }
-        if (channel.limit !== undefined) {
-            expanded.limit = channel.limit;
+        if (route.order !== undefined) {
+            result.order = route.order;
         }
-        if (channel.rss !== undefined) {
-            expanded.rss = channel.rss;
+        if (route.limit !== undefined) {
+            result.limit = route.limit;
         }
-    } else {
-        const template = route as TemplateRoute;
-        if (template.contentType !== undefined) {
-            expanded.content_type = template.contentType;
+        if (route.rss !== undefined) {
+            result.rss = route.rss;
         }
+        return result;
     }
 
-    return expanded;
+    const result: RouterTemplateRoute = {
+        path: route.path,
+        type: 'template',
+        templates: route.templates || []
+    };
+    if (data !== undefined) {
+        result.data = data;
+    }
+    if (route.contentType !== undefined) {
+        result.contentType = route.contentType;
+    }
+    return result;
 }
 
-function expandCollection(collection: CollectionConfig): Record<string, any> {
-    const expanded: Record<string, any> = {};
-
-    expanded.permalink = convertSlugsToColons(collection.permalink);
-    expanded.templates = collection.templates || [];
+function buildRouterCollection(collection: CollectionConfig): RouterCollection {
+    const result: RouterCollection = {
+        path: collection.path,
+        permalink: convertSlugsToColons(collection.permalink),
+        templates: collection.templates || []
+    };
 
     if (collection.data !== undefined) {
-        expanded.data = expandRouteData(collection.data);
+        result.data = expandRouteData(collection.data);
     }
-
     if (collection.filter !== undefined) {
-        expanded.filter = collection.filter;
+        result.filter = collection.filter;
     }
     if (collection.order !== undefined) {
-        expanded.order = collection.order;
+        result.order = collection.order;
     }
     if (collection.limit !== undefined) {
-        expanded.limit = collection.limit;
+        result.limit = collection.limit;
     }
     if (collection.rss !== undefined) {
-        expanded.rss = collection.rss;
+        result.rss = collection.rss;
     }
 
-    return expanded;
+    return result;
 }
 
 /**
- * Converts a RouteSettings domain model into the legacy expanded format
- * that routerManager.start() expects.
+ * Converts a RouteSettings domain model into the array shape that
+ * RouterManager.start() iterates. Each route/collection carries its own `path`,
+ * and taxonomies become `{key, permalink}` entries, so the routing layer no
+ * longer reads paths from map keys.
  *
- * This is a temporary adapter — it gets removed once RouterManager is
- * refactored to consume the domain model directly (HKG-1895/HKG-1898).
+ * Temporary adapter: removed in HKG-1898 once the routers consume the domain
+ * model directly.
  */
-export function expandRouteSettings(settings: RouteSettings): {routes: Record<string, any>; collections: Record<string, any>; taxonomies: Record<string, string>} {
-    const routes: Record<string, any> = {};
-    for (const route of settings.routes) {
-        routes[route.path] = expandRoute(route);
-    }
-
-    const collections: Record<string, any> = {};
-    for (const collection of settings.collections) {
-        collections[collection.path] = expandCollection(collection);
-    }
-
-    const taxonomies: Record<string, string> = {};
+export function buildRouterSettings(settings: RouteSettings): RouterSettings {
+    const taxonomies: RouterTaxonomy[] = [];
     for (const [key, value] of Object.entries(settings.taxonomies)) {
         if (value) {
-            taxonomies[key] = convertSlugsToColons(value);
+            taxonomies.push({key, permalink: convertSlugsToColons(value)});
         }
     }
 
-    return {routes, collections, taxonomies};
+    return {
+        routes: settings.routes.map(buildRouterRoute),
+        collections: settings.collections.map(buildRouterCollection),
+        taxonomies
+    };
 }

package/core/server/services/route-settings/dynamic-routing-service.js

@@ -1,5 +1,3 @@
-const crypto = require('crypto');
-const fs = require('fs-extra');
 const debug = require('@tryghost/debug')('services:route-settings:service');
 const logging = require('@tryghost/logging');
 const errors = require('@tryghost/errors');
@@ -9,12 +7,6 @@ const messages = {
     loadError: 'Could not load routes.yaml file.'
 };
 
-/**
- * md5 of the expanded default route settings — the routes_hash value for a
- * site that has never customised its routes.
- */
-const DEFAULT_ROUTES_SETTING_HASH = '3d180d52c663d173a6be791ef411ed01';
-
 function isStoredContentError(err) {
     return err.errorType === 'ValidationError' || err.errorType === 'IncorrectUsageError';
 }
@@ -27,26 +19,21 @@ class DynamicRoutingService {
     constructor() {
         /** @type {RouteSettingsStore} */
         this.store = null;
-        this.settingsLoader = null;
         this.routerManager = null;
         this.urlService = null;
     }
 
     /**
-     * Wire the storage-layer dependencies so the API surface (upload, download,
-     * getCurrentHash) works immediately after boot — even when the frontend is
-     * disabled and `start()` is never called.
+     * Wire the storage-layer dependency so the API surface (upload, download)
+     * works immediately after boot — even when the frontend is disabled and
+     * `start()` is never called.
      *
      * @param {object} deps
      * @param {RouteSettingsStore} deps.store - adapter-manager provided store
-     * @param {object} [deps.settingsLoader]  - legacy SettingsLoader used as a
-     *        read-path fallback when the stricter store parser rejects a file
-     *        (see loadRouteSettings)
      */
-    configure({store, settingsLoader}) {
+    configure({store}) {
         debug('configure');
         this.store = store;
-        this.settingsLoader = settingsLoader;
     }
 
     /**
@@ -67,49 +54,33 @@ class DynamicRoutingService {
     }
 
     async loadRouteSettings() {
-        const {expandRouteSettings} = require('./activation-bridge');
+        const {buildRouterSettings} = require('./activation-bridge');
 
         try {
-            return expandRouteSettings(await this.store.get());
+            return buildRouterSettings(await this.store.get());
         } catch (err) {
-            if (!this.settingsLoader || err.errorType !== 'ValidationError') {
-                throw err;
+            // A stored-content error means the site's routes.yaml is invalid —
+            // either it fails validation or it isn't parseable YAML. Log a
+            // targeted error so the failure is easy to spot in the logs, then
+            // rethrow so the caller surfaces the genuine error rather than
+            // silently degrading.
+            if (isStoredContentError(err)) {
+                logging.error(new errors.InternalServerError({
+                    message: 'Route settings could not be loaded because the routes.yaml file is invalid. Please fix the file.',
+                    code: 'ROUTE_SETTINGS_VALIDATION_ERROR',
+                    err,
+                    errorDetails: {reason: err.message}
+                }));
             }
-            logging.error(new errors.InternalServerError({
-                message: 'Route settings failed the stricter validation and were loaded with the legacy validator instead. Please review the routes.yaml file.',
-                code: 'ROUTE_SETTINGS_VALIDATION_FALLBACK',
-                err,
-                errorDetails: {reason: err.message}
-            }));
-
-            return this.settingsLoader.loadSettings();
-        }
-    }
-
-    getDefaultHash() {
-        return DEFAULT_ROUTES_SETTING_HASH;
-    }
 
-    async getCurrentHash() {
-        const expanded = await this.loadRouteSettings();
-
-        return crypto.createHash('md5')
-            .update(JSON.stringify(expanded), 'binary')
-            .digest('hex');
+            throw err;
+        }
     }
 
     async download() {
-        try {
-            const settings = await this.store.get();
-
-            return settings.yamlSource;
-        } catch (err) {
-            if (!this.settingsLoader || !isStoredContentError(err)) {
-                throw err;
-            }
+        const settings = await this.store.get();
 
-            return fs.readFile(this.settingsLoader.settingFilePath, 'utf8');
-        }
+        return settings.yamlSource;
     }
 
     async upload(yamlContent) {

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

@@ -1,5 +1,3 @@
-const config = require('../../../shared/config');
-const parseYaml = require('./yaml-parser');
 const DynamicRoutingService = require('./dynamic-routing-service');
 
 const service = new DynamicRoutingService();
@@ -7,15 +5,9 @@ const service = new DynamicRoutingService();
 module.exports = {
     init: async () => {
         const adapterManager = require('../adapter-manager').default;
-        const SettingsLoader = require('./settings-loader');
-        const SettingsPathManager = require('./settings-path-manager');
-
-        const settingsPathManager = new SettingsPathManager({type: 'routes', paths: [config.getContentPath('settings')]});
-        const settingsLoader = new SettingsLoader({parseYaml, settingFilePath: settingsPathManager.getDefaultFilePath()});
 
         service.configure({
-            store: adapterManager.getAdapter('route-settings'),
-            settingsLoader
+            store: adapterManager.getAdapter('route-settings')
         });
     },
 
@@ -27,10 +19,6 @@ module.exports = {
         return service.loadRouteSettings.bind(service);
     },
 
-    get getDefaultHash() {
-        return service.getDefaultHash.bind(service);
-    },
-
     /**
      * Methods backing the Admin API settings endpoint — delegate to the
      * service instance so the endpoint stays decoupled from service wiring.
@@ -41,9 +29,6 @@ module.exports = {
         },
         get download() {
             return service.download.bind(service);
-        },
-        get getCurrentHash() {
-            return service.getCurrentHash.bind(service);
         }
     }
 };

package/core/server/services/settings/settings-service.js

@@ -183,24 +183,6 @@ module.exports = {
         return fields;
     },
 
-    /**
-     * Handles synchronization of routes.yaml hash loaded in the frontend with
-     * the value stored in the settings table.
-     * getRoutesHash is a function to allow keeping "frontend" decoupled from settings
-     *
-     * @param {function} getRoutesHash function fetching currently loaded routes file hash
-     */
-    async syncRoutesHash(getRoutesHash) {
-        const currentRoutesHash = await getRoutesHash();
-
-        if (SettingsCache.get('routes_hash') !== currentRoutesHash) {
-            return await models.Settings.edit([{
-                key: 'routes_hash',
-                value: currentRoutesHash
-            }], {context: {internal: true}});
-        }
-    },
-
     /**
      * Handles email setting synchronization when email has been verified per instance
      *

package/core/server/services/themes/storage.js

@@ -27,6 +27,8 @@ const messages = {
     destroyActive: 'Deleting the active theme is not allowed.'
 };
 
+const INVALID_THEME_REGEX = /^[./]*$/;
+
 let themeStorage;
 
 const getStorage = () => {
@@ -60,6 +62,13 @@ module.exports = {
             });
         }
 
+        // Reject theme names that only contain path elements.
+        if (INVALID_THEME_REGEX.test(themeName)) {
+            throw new errors.ValidationError({
+                message: 'Invalid theme name.'
+            });
+        }
+
         let checkedTheme;
         let overrideTheme;
         let renamedExisting = false;

package/core/server/services/themes/theme-storage.js

@@ -4,7 +4,7 @@ const path = require('path');
 const config = require('../../../shared/config');
 const security = require('@tryghost/security');
 const {compress} = require('@tryghost/zip');
-const LocalStorageBase = require('../../adapters/storage/LocalStorageBase');
+const LocalStorageBase = require('../../adapters/storage/LocalStorageBase').default;
 
 /**
  * @TODO: combine with loader.js?

package/core/server/services/url/url-service-facade.js

@@ -49,7 +49,7 @@ class UrlServiceFacade {
         }
         const url = this.urlService.getUrlByResourceId(resource.id, options);
         if (this.isComparing() && !options?.skipComparison) {
-            const context = this._compareContext(resource);
+            const context = this._compareContext(resource, options?.serializerContext ? { serializer: options.serializerContext } : {});
             // Snapshot: callers mutate the resource's nested objects in place
             // after this returns, but the comparison runs later via setImmediate.
             const snapshot = _.cloneDeep(resource);

package/core/server/services/url/url-service-facade.ts

@@ -43,6 +43,12 @@ export interface UrlOptions {
     // rows per rebuild would only capture stacks and recompute for nothing.
     // Dies with compare mode.
     skipComparison?: boolean;
+    // Diagnostic only: the producing api endpoint (docName/method/apiType),
+    // threaded from the output serializer so a compare mismatch or thin-resource
+    // throw names its producer in the logs. The compare-log caller stack
+    // truncates at the async api-framework boundary, so the stack alone can't.
+    // Ignored by both backends; only read into the compare context.
+    serializerContext?: {apiType?: string; docName?: string; method?: string};
 }
 
 /**
@@ -138,7 +144,8 @@ export class UrlServiceFacade {
         }
         const url = this.urlService.getUrlByResourceId(resource.id, options);
         if (this.isComparing() && !options?.skipComparison) {
-            const context = this._compareContext(resource);
+            const context = this._compareContext(resource,
+                options?.serializerContext ? {serializer: options.serializerContext} : {});
             // Snapshot: callers mutate the resource's nested objects in place
             // after this returns, but the comparison runs later via setImmediate.
             const snapshot = _.cloneDeep(resource);

package/core/server/web/api/endpoints/admin/routes.js

@@ -208,6 +208,7 @@ module.exports = function apiRoutes() {
 
     // ## Automations
     router.get('/automations', mw.authAdminApi, http(api.automations.browse));
+    router.get('/automations/:automation_id/actions/:action_id/links', mw.authAdminApi, http(api.automationActionLinks.browse));
     router.get('/automations/:id', mw.authAdminApi, http(api.automations.read));
     router.post('/automations/:id/email_preview', mw.authAdminApi, http(api.automationEmailPreviews.preview));
     router.post('/automations/:id/email_test', shared.middleware.brute.previewEmailLimiter, mw.authAdminApi, http(api.automationEmailPreviews.sendTestEmail));

package/core/shared/config/defaults.json

@@ -366,5 +366,6 @@
         "captureLinkClickBadMemberUuid": false
     },
     "disableJSBackups": false,
-    "disableMigrationBackups": false
+    "disableMigrationBackups": false,
+    "usingLoopbackReverseProxy": false
 }

package/core/shared/express.js

@@ -2,6 +2,7 @@ const debug = require('@tryghost/debug')('shared:express');
 const express = require('express');
 const {createLazyRouter} = require('express-lazy-router');
 const sentry = require('./sentry');
+const config = require('../../core/shared/config');
 
 const lazyLoad = createLazyRouter();
 
@@ -17,7 +18,11 @@ module.exports = (name) => {
 
     // Make sure 'req.secure' is valid for proxied requests
     // (X-Forwarded-Proto header will be checked, if present)
-    app.enable('trust proxy');
+    if (config.get('usingLoopbackReverseProxy')) {
+        app.set('trust proxy', 'loopback');
+    } else {
+        app.enable('trust proxy');
+    }
 
     // Sentry must be our first error handler. Mounting it here means all custom error handlers will come after
     app.use(sentry.errorHandler);

package/core/shared/labs.js

@@ -64,7 +64,8 @@ const PRIVATE_FEATURES = [
     'getHelperDeduplication',
     'memberDetailsReact',
     'membersCustomFields',
-    'previewByTier'
+    'previewByTier',
+    'paywallImprovements'
 ];
 
 module.exports.GA_KEYS = [...GA_FEATURES];