ghost 6.54.1 → 6.55.0

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

@@ -47,6 +47,9 @@ let membersApi;
 let verificationTrigger;
 
 const buildImporterDeps = ({stripeAPIService}) => {
+    // Required here, not statically: boot builds the custom fields services before this
+    // one (the exporter below relies on the same).
+    const customFields = require('../members-custom-fields');
     return {
         getTimezone: () => settingsCache.get('timezone'),
         // A getter rather than a value because the threshold is an operator
@@ -81,7 +84,11 @@ const buildImporterDeps = ({stripeAPIService}) => {
         knex: db.knex,
         urlFor: urlUtils.urlFor.bind(urlUtils),
         stripeAPIService,
-        productRepository: membersApi.productRepository
+        productRepository: membersApi.productRepository,
+        customFields: {
+            definitions: customFields.definitions,
+            values: customFields.values
+        }
     };
 };
 

package/core/server/services/members-custom-fields/values-service.js

@@ -137,8 +137,9 @@ class CustomFieldValuesService {
     /**
      * Resolve input into the writes it implies, rejecting anything invalid, and
      * writing nothing. Returned so a caller can validate before it commits to a
-     * change it would have to unwind (the member edit validates up front), then
-     * apply the same plan without re-resolving or re-validating.
+     * change it would have to unwind (the member edit and the importer both validate
+     * up front, before opening a transaction), then apply the same plan without
+     * re-resolving or re-validating.
      */
     async planWrite(input) {
         const values = this.parseValues(input);
@@ -191,14 +192,17 @@ class CustomFieldValuesService {
      * Apply a plan from `planWrite`.
      *
      * Merge, not replace: only the fields in the plan are touched, so a caller
-     * that doesn't know about a field can't erase it. The whole plan is applied in
-     * one transaction, so a mid-batch failure rolls the batch back.
+     * that doesn't know about a field can't erase it.
+     *
+     * Always transactional, so a mid-batch failure rolls the batch back. Passed an
+     * executor it joins that transaction -- the importer passes its per-member one, so a
+     * failed value write takes the member with it; passed nothing it opens its own.
      */
-    async applyWrite(memberId, writes) {
+    async applyWrite(memberId, writes, executor = this.knex) {
         if (writes.length === 0) {
             return;
         }
-        await this.knex.transaction(async (trx) => {
+        const apply = async (trx) => {
             for (const { field, value } of writes) {
                 const target = { member_id: memberId, custom_field_id: field.id };
                 if (value === undefined) {
@@ -213,7 +217,15 @@ class CustomFieldValuesService {
                     .onConflict(['member_id', 'custom_field_id'])
                     .merge({ ...valueColumns, updated_at: new Date() });
             }
-        });
+        };
+        // isTransaction is knex's marker for a transactor: join an existing transaction
+        // rather than nesting a savepoint under it, otherwise open one.
+        if (executor.isTransaction) {
+            await apply(executor);
+        }
+        else {
+            await executor.transaction(apply);
+        }
     }
 }
 exports.CustomFieldValuesService = CustomFieldValuesService;

package/core/server/services/members-custom-fields/values-service.ts

@@ -164,8 +164,9 @@ export class CustomFieldValuesService {
     /**
      * Resolve input into the writes it implies, rejecting anything invalid, and
      * writing nothing. Returned so a caller can validate before it commits to a
-     * change it would have to unwind (the member edit validates up front), then
-     * apply the same plan without re-resolving or re-validating.
+     * change it would have to unwind (the member edit and the importer both validate
+     * up front, before opening a transaction), then apply the same plan without
+     * re-resolving or re-validating.
      */
     async planWrite(input: unknown): Promise<PlannedWrite[]> {
         const values = this.parseValues(input);
@@ -225,15 +226,18 @@ export class CustomFieldValuesService {
      * Apply a plan from `planWrite`.
      *
      * Merge, not replace: only the fields in the plan are touched, so a caller
-     * that doesn't know about a field can't erase it. The whole plan is applied in
-     * one transaction, so a mid-batch failure rolls the batch back.
+     * that doesn't know about a field can't erase it.
+     *
+     * Always transactional, so a mid-batch failure rolls the batch back. Passed an
+     * executor it joins that transaction -- the importer passes its per-member one, so a
+     * failed value write takes the member with it; passed nothing it opens its own.
      */
-    async applyWrite(memberId: string, writes: PlannedWrite[]): Promise<void> {
+    async applyWrite(memberId: string, writes: PlannedWrite[], executor: Knex = this.knex): Promise<void> {
         if (writes.length === 0) {
             return;
         }
 
-        await this.knex.transaction(async (trx) => {
+        const apply = async (trx: Knex) => {
             for (const {field, value} of writes) {
                 const target = {member_id: memberId, custom_field_id: field.id};
 
@@ -250,6 +254,14 @@ export class CustomFieldValuesService {
                     .onConflict(['member_id', 'custom_field_id'])
                     .merge({...valueColumns, updated_at: new Date()});
             }
-        });
+        };
+
+        // isTransaction is knex's marker for a transactor: join an existing transaction
+        // rather than nesting a savepoint under it, otherwise open one.
+        if (executor.isTransaction) {
+            await apply(executor);
+        } else {
+            await executor.transaction(apply);
+        }
     }
 }

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

@@ -29,7 +29,11 @@ async function getPostData(post) {
 
 function getPostUrl(id, postData) {
     const jsonModel = {...postData};
-    outputSerializerUrlUtil.forPost(id, jsonModel, {options: {}});
+    // The URL service routes by resource type. Pages and posts share the Post
+    // model, so the page's own type must reach forPost — otherwise it defaults
+    // to 'posts', matches no post collection, and 404s under the lazy service.
+    const type = postData.type === 'page' ? 'pages' : 'posts';
+    outputSerializerUrlUtil.forPost(id, jsonModel, {options: {}}, type);
     return jsonModel.url;
 }
 

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/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);